{"nbformat":4,"nbformat_minor":0,"metadata":{"accelerator":"GPU","colab":{"name":"convolutional_networks.ipynb","provenance":[{"file_id":"1IZw9jVe-WgGTojdJFGjP-DOqz_ERVUA6","timestamp":1603106807406}],"collapsed_sections":[],"toc_visible":true},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.7.1"},"widgets":{"application/vnd.jupyter.widget-state+json":{"4a349e9fa7064ad2a20d239cfcdc9995":{"model_module":"@jupyter-widgets/controls","model_name":"HBoxModel","state":{"_view_name":"HBoxView","_dom_classes":[],"_model_name":"HBoxModel","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.5.0","box_style":"","layout":"IPY_MODEL_9c1ff24488d24e86979b4f6d887973cc","_model_module":"@jupyter-widgets/controls","children":["IPY_MODEL_dc8833d39c234339ab44c1e5e0238d71","IPY_MODEL_0ed9a81ecfe34852ab7f67b419224944"]}},"9c1ff24488d24e86979b4f6d887973cc":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"dc8833d39c234339ab44c1e5e0238d71":{"model_module":"@jupyter-widgets/controls","model_name":"FloatProgressModel","state":{"_view_name":"ProgressView","style":"IPY_MODEL_0d33896120964d9d873868094992bf1c","_dom_classes":[],"description":"","_model_name":"FloatProgressModel","bar_style":"success","max":1,"_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":1,"_view_count":null,"_view_module_version":"1.5.0","orientation":"horizontal","min":0,"description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_b3d1c9d83e744e76be42f2599253a5ec"}},"0ed9a81ecfe34852ab7f67b419224944":{"model_module":"@jupyter-widgets/controls","model_name":"HTMLModel","state":{"_view_name":"HTMLView","style":"IPY_MODEL_151d696da27b425db76e9c60a56c7bb8","_dom_classes":[],"description":"","_model_name":"HTMLModel","placeholder":"​","_view_module":"@jupyter-widgets/controls","_model_module_version":"1.5.0","value":" 170500096/? [00:05&lt;00:00, 31642081.44it/s]","_view_count":null,"_view_module_version":"1.5.0","description_tooltip":null,"_model_module":"@jupyter-widgets/controls","layout":"IPY_MODEL_2e3aec24d2db4ae88b379bb5a10685a1"}},"0d33896120964d9d873868094992bf1c":{"model_module":"@jupyter-widgets/controls","model_name":"ProgressStyleModel","state":{"_view_name":"StyleView","_model_name":"ProgressStyleModel","description_width":"initial","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","bar_color":null,"_model_module":"@jupyter-widgets/controls"}},"b3d1c9d83e744e76be42f2599253a5ec":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}},"151d696da27b425db76e9c60a56c7bb8":{"model_module":"@jupyter-widgets/controls","model_name":"DescriptionStyleModel","state":{"_view_name":"StyleView","_model_name":"DescriptionStyleModel","description_width":"","_view_module":"@jupyter-widgets/base","_model_module_version":"1.5.0","_view_count":null,"_view_module_version":"1.2.0","_model_module":"@jupyter-widgets/controls"}},"2e3aec24d2db4ae88b379bb5a10685a1":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":null,"min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}}}}},"cells":[{"cell_type":"markdown","metadata":{"id":"DDJwQPZcupab"},"source":["# EECS 498-007/598-005 Assignment 3-2: Convolutional Neural Networks and Batch Normalization\n","\n","Before we start, please put your name and UMID in following format\n","\n",": Firstname LASTNAME, #00000000   //   e.g.) Justin JOHNSON, #12345678"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"MfdNnZeyNRPZ","executionInfo":{"status":"ok","timestamp":1606136750518,"user_tz":-480,"elapsed":1748,"user":{"displayName":"young","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GjuSwIMBj1x2bJOgTT5-3wA8Yt5zgRoz7viNvKn=s64","userId":"11870005096077095950"}},"outputId":"75540028-b3eb-4c61-e612-f9d7ad7deb08"},"source":["from google.colab import drive\n","drive.mount('/content/drive')"],"execution_count":2,"outputs":[{"output_type":"stream","text":["Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"A4dxgcxCNnEl","executionInfo":{"status":"ok","timestamp":1606136799659,"user_tz":-480,"elapsed":1295,"user":{"displayName":"young","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GjuSwIMBj1x2bJOgTT5-3wA8Yt5zgRoz7viNvKn=s64","userId":"11870005096077095950"}},"outputId":"06662736-58f6-4c42-aac1-755d24e0515d"},"source":[""],"execution_count":3,"outputs":[{"output_type":"stream","text":["drive  sample_data\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"aQW_w1Wzw72f","tags":["pdf-title"]},"source":["# Convolutional networks\n","So far we have worked with deep fully-connected networks, using them to explore different optimization strategies and network architectures. Fully-connected networks are a good testbed for experimentation because they are very computationally efficient, but in practice all state-of-the-art results use convolutional networks instead.\n","\n","First you will implement several layer types that are used in convolutional networks. You will then use these layers to train a convolutional network on the CIFAR-10 dataset."]},{"cell_type":"markdown","metadata":{"id":"ubB_0e-UAOVK"},"source":["## Install starter code\n","We will continue using the utility functions that we've used for Assignment 1 and 2: [`coutils` package](https://github.com/deepvision-class/starter-code). Run this cell to download and install it.\n"]},{"cell_type":"code","metadata":{"id":"ASkY27ZtA7Is","colab":{"base_uri":"https://localhost:8080/","height":464},"executionInfo":{"status":"ok","timestamp":1603867446149,"user_tz":-480,"elapsed":5636,"user":{"displayName":"young Zhao","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GjuSwIMBj1x2bJOgTT5-3wA8Yt5zgRoz7viNvKn=s64","userId":"11870005096077095950"}},"outputId":"66122655-0e8c-467c-9889-39d2430e8549"},"source":["!pip install git+https://github.com/deepvision-class/starter-code"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Collecting git+https://github.com/deepvision-class/starter-code\n","  Cloning https://github.com/deepvision-class/starter-code to /tmp/pip-req-build-d5guh9u4\n","  Running command git clone -q https://github.com/deepvision-class/starter-code /tmp/pip-req-build-d5guh9u4\n","Requirement already satisfied: pydrive in /usr/local/lib/python3.6/dist-packages (from Colab-Utils==0.1.dev0) (1.3.1)\n","Requirement already satisfied: google-api-python-client>=1.2 in /usr/local/lib/python3.6/dist-packages (from pydrive->Colab-Utils==0.1.dev0) (1.7.12)\n","Requirement already satisfied: oauth2client>=4.0.0 in /usr/local/lib/python3.6/dist-packages (from pydrive->Colab-Utils==0.1.dev0) (4.1.3)\n","Requirement already satisfied: PyYAML>=3.0 in /usr/local/lib/python3.6/dist-packages (from pydrive->Colab-Utils==0.1.dev0) (3.13)\n","Requirement already satisfied: httplib2<1dev,>=0.17.0 in /usr/local/lib/python3.6/dist-packages (from google-api-python-client>=1.2->pydrive->Colab-Utils==0.1.dev0) (0.17.4)\n","Requirement already satisfied: uritemplate<4dev,>=3.0.0 in /usr/local/lib/python3.6/dist-packages (from google-api-python-client>=1.2->pydrive->Colab-Utils==0.1.dev0) (3.0.1)\n","Requirement already satisfied: google-auth>=1.4.1 in /usr/local/lib/python3.6/dist-packages (from google-api-python-client>=1.2->pydrive->Colab-Utils==0.1.dev0) (1.17.2)\n","Requirement already satisfied: six<2dev,>=1.6.1 in /usr/local/lib/python3.6/dist-packages (from google-api-python-client>=1.2->pydrive->Colab-Utils==0.1.dev0) (1.15.0)\n","Requirement already satisfied: google-auth-httplib2>=0.0.3 in /usr/local/lib/python3.6/dist-packages (from google-api-python-client>=1.2->pydrive->Colab-Utils==0.1.dev0) (0.0.4)\n","Requirement already satisfied: pyasn1>=0.1.7 in /usr/local/lib/python3.6/dist-packages (from oauth2client>=4.0.0->pydrive->Colab-Utils==0.1.dev0) (0.4.8)\n","Requirement already satisfied: rsa>=3.1.4 in /usr/local/lib/python3.6/dist-packages (from oauth2client>=4.0.0->pydrive->Colab-Utils==0.1.dev0) (4.6)\n","Requirement already satisfied: pyasn1-modules>=0.0.5 in /usr/local/lib/python3.6/dist-packages (from oauth2client>=4.0.0->pydrive->Colab-Utils==0.1.dev0) (0.2.8)\n","Requirement already satisfied: setuptools>=40.3.0 in /usr/local/lib/python3.6/dist-packages (from google-auth>=1.4.1->google-api-python-client>=1.2->pydrive->Colab-Utils==0.1.dev0) (50.3.0)\n","Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from google-auth>=1.4.1->google-api-python-client>=1.2->pydrive->Colab-Utils==0.1.dev0) (4.1.1)\n","Building wheels for collected packages: Colab-Utils\n","  Building wheel for Colab-Utils (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for Colab-Utils: filename=Colab_Utils-0.1.dev0-cp36-none-any.whl size=10324 sha256=6d19a3f89ab913b67914055dfe4bf8063e38da856d7e104648cb076f2265f551\n","  Stored in directory: /tmp/pip-ephem-wheel-cache-fuffelev/wheels/63/d1/27/a208931527abb98d326d00209f46c80c9d745851d6a1defd10\n","Successfully built Colab-Utils\n","Installing collected packages: Colab-Utils\n","Successfully installed Colab-Utils-0.1.dev0\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"MzqbYcKdz6ew"},"source":["## Setup code\n","Run some setup code for this notebook: Import some useful packages and increase the default figure size."]},{"cell_type":"code","metadata":{"id":"vixlKb-ew72h","tags":["pdf-ignore"]},"source":["import math\n","import torch\n","import coutils\n","from coutils import extract_drive_file_id, register_colab_notebooks, \\\n","                    fix_random_seed, rel_error, compute_numeric_gradient, Solver\n","import matplotlib.pyplot as plt\n","import time\n","\n","# for plotting\n","%matplotlib inline\n","plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n","plt.rcParams['image.interpolation'] = 'nearest'\n","plt.rcParams['image.cmap'] = 'gray'\n","\n","# data type and device for torch.tensor\n","to_float = {'dtype': torch.float, 'device': 'cpu'}\n","to_float_cuda = {'dtype': torch.float, 'device': 'cuda'}\n","to_double = {'dtype': torch.double, 'device': 'cpu'}\n","to_double_cuda = {'dtype': torch.double, 'device': 'cuda'}\n","to_long = {'dtype': torch.long, 'device': 'cpu'}\n","to_long_cuda = {'dtype': torch.long, 'device': 'cuda'}"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"0Saw9jGNm-9-"},"source":["## Import functions from previous notebook\n","This notebook will re-use some pieces of code that you implemented in the previous notebook.\n","\n","In order to do this, you will need the **Google Drive file ID** of your completed notebook `fully_connected_networks.ipynb`. You can find the this file ID by doing the following:\n","1. Make sure you have saved your completed `fully_connected_networks.ipynb` notebook to your own Google Drive\n","2. Open you finished `fully_connected_networks.ipynb` notebook in Colab.\n","3. Click the \"Share\" button at the top of the screen\n","4. Copy the \"Notebook link\" and paste it in the following cell, assigning it to the `FULLY_CONNECTED_NOTEBOOK_LINK` variable\n","\n","**Important:** If you modify the implementations of any functions in your `fully_connected_networks.ipynb` notebook, **they will not automatically be propagated to this notebook**. For changes to `fully_connected_networks.ipynb` to be propagated to this notebook, you will need to:\n","1. Make sure that you save your modified `fully_connected_networks.ipynb` notebook (File > Save)\n","2. Restart the runtime of this notebook (Runtime > Restart Runtime)\n","3. Rerun all cells in this notebook (in particular the import cell below)"]},{"cell_type":"code","metadata":{"id":"Xq5yHDeuklId","colab":{"base_uri":"https://localhost:8080/","height":52},"executionInfo":{"status":"ok","timestamp":1603868135749,"user_tz":-480,"elapsed":2569,"user":{"displayName":"young Zhao","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GjuSwIMBj1x2bJOgTT5-3wA8Yt5zgRoz7viNvKn=s64","userId":"11870005096077095950"}},"outputId":"07cedc41-d4d1-412b-b565-37c13061a1bf"},"source":["FULLY_CONNECTED_NOTEBOOK_LINK = \"https://colab.research.google.com/drive/1GcQuWQwOZRjJZaHwk2tBioeQqyXF-edA\"\n","\n","fcn_id = extract_drive_file_id(FULLY_CONNECTED_NOTEBOOK_LINK)\n","print('Google Drive file id: \"%s\"' % fcn_id)\n","register_colab_notebooks({'fully_connected_networks': fcn_id})\n","\n","from fully_connected_networks import get_CIFAR10_data\n","from fully_connected_networks import Linear, ReLU, Linear_ReLU, Dropout\n","from fully_connected_networks import svm_loss, softmax_loss\n","from fully_connected_networks import sgd_momentum, rmsprop, adam\n","\n","print('Import successful!')"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Google Drive file id: \"1GcQuWQwOZRjJZaHwk2tBioeQqyXF-edA\"\n","Import successful!\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"HpqGVD5mnjYF"},"source":["## Load CIFAR-10 data\n","\n","Here we load up our favorite CIFAR-10 data so we can use it to train a classifier on a real dataset."]},{"cell_type":"code","metadata":{"id":"rEjt-AJRG5dp","colab":{"base_uri":"https://localhost:8080/","height":538,"referenced_widgets":["4a349e9fa7064ad2a20d239cfcdc9995","9c1ff24488d24e86979b4f6d887973cc","dc8833d39c234339ab44c1e5e0238d71","0ed9a81ecfe34852ab7f67b419224944","0d33896120964d9d873868094992bf1c","b3d1c9d83e744e76be42f2599253a5ec","151d696da27b425db76e9c60a56c7bb8","2e3aec24d2db4ae88b379bb5a10685a1"]},"executionInfo":{"status":"ok","timestamp":1603868146821,"user_tz":-480,"elapsed":6911,"user":{"displayName":"young Zhao","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GjuSwIMBj1x2bJOgTT5-3wA8Yt5zgRoz7viNvKn=s64","userId":"11870005096077095950"}},"outputId":"f005a6c5-aeca-41f2-cf7b-4dd2640e5959"},"source":["# Invoke the above function to get our data.\n","data_dict = get_CIFAR10_data(visualize=True)\n","print('Train data shape: ', data_dict['X_train'].shape)\n","print('Train labels shape: ', data_dict['y_train'].shape)\n","print('Validation data shape: ', data_dict['X_val'].shape)\n","print('Validation labels shape: ', data_dict['y_val'].shape)\n","print('Test data shape: ', data_dict['X_test'].shape)\n","print('Test labels shape: ', data_dict['y_test'].shape)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./cifar-10-python.tar.gz\n"],"name":"stdout"},{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"4a349e9fa7064ad2a20d239cfcdc9995","version_minor":0,"version_major":2},"text/plain":["HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"]},"metadata":{"tags":[]}},{"output_type":"stream","text":["Extracting ./cifar-10-python.tar.gz to .\n"],"name":"stdout"},{"output_type":"stream","text":["/usr/local/lib/python3.6/dist-packages/coutils/utils.py:54: UserWarning: This overload of nonzero is deprecated:\n","\tnonzero()\n","Consider using one of the following signatures instead:\n","\tnonzero(*, bool as_tuple) (Triggered internally at  /pytorch/torch/csrc/utils/python_arg_parser.cpp:766.)\n","  idxs = (y_data == y).nonzero().view(-1)\n"],"name":"stderr"},{"output_type":"stream","text":["\n"],"name":"stdout"},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 720x576 with 2 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}},{"output_type":"stream","text":["Train data shape:  torch.Size([47500, 3, 32, 32])\n","Train labels shape:  torch.Size([47500])\n","Validation data shape:  torch.Size([2500, 3, 32, 32])\n","Validation labels shape:  torch.Size([2500])\n","Test data shape:  torch.Size([10000, 3, 32, 32])\n","Test labels shape:  torch.Size([10000])\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"CJInAlccoI5e"},"source":["# Convolutional layer\n","As in the previous notebook, we will package each new neural network operator in a class that defines a `forward` and `backward` function."]},{"cell_type":"code","metadata":{"id":"N8ZohWR-o_uc"},"source":["class Conv(object):\n","\n","  @staticmethod\n","  def forward(x, w, b, conv_param):\n","    raise NotImplementedError\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    raise NotImplementedError"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"x07DS91iw72o"},"source":["## Convolutional layer: forward\n","The core of a convolutional network is the convolution operation. Implement the forward pass for the convolution layer in the function `Conv.forward`. \n","\n","You don't have to worry too much about efficiency at this point; just write the code in whatever way you find most clear.\n","\n","You can test your implementation by running the following:"]},{"cell_type":"code","metadata":{"id":"48TBbwG0n7WK"},"source":["def conv_forward(x, w, b, conv_param):\n","  \"\"\"\n","  A naive implementation of the forward pass for a convolutional layer.\n","  The input consists of N data points, each with C channels, height H and\n","  width W. We convolve each input with F different filters, where each filter\n","  spans all C channels and has height HH and width WW.\n","\n","  Input:\n","  - x: Input data of shape (N, C, H, W)\n","  - w: Filter weights of shape (F, C, HH, WW)\n","  - b: Biases, of shape (F,)\n","  - conv_param: A dictionary with the following keys:\n","    - 'stride': The number of pixels between adjacent receptive fields in the\n","    horizontal and vertical directions.\n","    - 'pad': The number of pixels that will be used to zero-pad the input. \n","    \n","  During padding, 'pad' zeros should be placed symmetrically (i.e equally on both sides)\n","  along the height and width axes of the input. Be careful not to modfiy the original\n","  input x directly.\n","\n","  Returns a tuple of:\n","  - out: Output data, of shape (N, F, H', W') where H' and W' are given by\n","    H' = 1 + (H + 2 * pad - HH) / stride\n","    W' = 1 + (W + 2 * pad - WW) / stride\n","  - cache: (x, w, b, conv_param)\n","  \"\"\"\n","  out = None\n","  ##############################################################################\n","  # TODO: Implement the convolutional forward pass.                            #\n","  # Hint: you can use the function torch.nn.functional.pad for padding.        #\n","  # Note that you are NOT allowed to use anything in torch.nn in other places. #\n","  ##############################################################################\n","  # Replace \"pass\" statement with your code\n","  N, _, H, W = x.shape\n","  F, _, kH, kW = w.shape\n","  stride = conv_param.get('stride', 1)\n","  pad = conv_param.get('pad', 0)\n","  assert (H + 2 * pad - kH) % stride == 0, 'Height Error'\n","  assert (W + 2 * pad - kW) % stride == 0, 'Width Error'\n","  H_prime = (H - kH + 2 * pad) // stride + 1\n","  W_prime = (H - kW + 2 * pad) // stride + 1\n","  kw = {'device': x.device, 'dtype': x.dtype}\n","  x_pad = torch.nn.functional.pad(x, (pad,pad,pad,pad)).to(x.dtype).to(x.device)\n","  out = torch.zeros(N, F, H_prime, W_prime,**kw)\n","\n","  for i in range(N):\n","    for j in range(F):\n","      for h in range(H_prime):\n","        for l in range(W_prime):\n","          out[i, j, h, l] = (x_pad[i, :, h*stride:h*stride+kH, l*stride:l*stride+kW] * w[j,:,:,:]).sum() + b[j]\n","\n","\n","\n","  #############################################################################\n","  #                              END OF YOUR CODE                             #\n","  #############################################################################\n","  cache = (x, w, b, conv_param)\n","  return out, cache\n","\n","Conv.forward = conv_forward"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"VeK1fneVy0N3"},"source":["After implementing the forward pass of the convolution operation, run the following to check your implementation. You should get a relative error less than `1e-7`."]},{"cell_type":"code","metadata":{"id":"F5R_WY1Iw72p","colab":{"base_uri":"https://localhost:8080/","height":52},"executionInfo":{"status":"ok","timestamp":1603872054028,"user_tz":-480,"elapsed":973,"user":{"displayName":"young Zhao","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GjuSwIMBj1x2bJOgTT5-3wA8Yt5zgRoz7viNvKn=s64","userId":"11870005096077095950"}},"outputId":"bdfde684-5d17-4bf4-adca-cb9ba197d4be"},"source":["x_shape = torch.tensor((2, 3, 4, 4))\n","w_shape = torch.tensor((3, 3, 4, 4))\n","x = torch.linspace(-0.1, 0.5, steps=torch.prod(x_shape), **to_double_cuda).reshape(*x_shape)\n","w = torch.linspace(-0.2, 0.3, steps=torch.prod(w_shape), **to_double_cuda).reshape(*w_shape)\n","b = torch.linspace(-0.1, 0.2, steps=3, **to_double_cuda)\n","\n","conv_param = {'stride': 2, 'pad': 1}\n","out, _ = Conv.forward(x, w, b, conv_param)\n","correct_out = torch.tensor([[[[-0.08759809, -0.10987781],\n","                              [-0.18387192, -0.2109216 ]],\n","                             [[ 0.21027089,  0.21661097],\n","                              [ 0.22847626,  0.23004637]],\n","                             [[ 0.50813986,  0.54309974],\n","                              [ 0.64082444,  0.67101435]]],\n","                            [[[-0.98053589, -1.03143541],\n","                              [-1.19128892, -1.24695841]],\n","                             [[ 0.69108355,  0.66880383],\n","                              [ 0.59480972,  0.56776003]],\n","                             [[ 2.36270298,  2.36904306],\n","                              [ 2.38090835,  2.38247847]]]], **to_double_cuda)\n","\n","# Compare your output to ours; difference should be around e-8\n","print('Testing Conv.forward')\n","print('difference: ', rel_error(out, correct_out))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Testing Conv.forward\n","difference:  4.424295217314395e-08\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"N5bKrl7Uw72t"},"source":["## Aside: Image processing via convolutions\n","\n","As fun way to both check your implementation and gain a better understanding of the type of operation that convolutional layers can perform, we will set up an input containing two images and manually set up filters that perform common image processing operations (grayscale conversion and edge detection). The convolution forward pass will apply these operations to each of the input images. We can then visualize the results as a sanity check."]},{"cell_type":"code","metadata":{"id":"k8BffZxdw72u","tags":["pdf-ignore-input"]},"source":["from imageio import imread\n","from PIL import Image\n","from torchvision.transforms import ToTensor\n","\n","kitten_url = 'https://web.eecs.umich.edu/~justincj/teaching/eecs498/assets/a3/kitten.jpg'\n","puppy_url = 'https://web.eecs.umich.edu/~justincj/teaching/eecs498/assets/a3/puppy.jpg'\n","\n","kitten = imread(kitten_url)\n","puppy = imread(puppy_url)\n","# kitten is wide, and puppy is already square\n","d = kitten.shape[1] - kitten.shape[0]\n","kitten_cropped = kitten[:, d//2:-d//2, :]\n","\n","img_size = 200   # Make this smaller if it runs too slow\n","resized_puppy = ToTensor()(Image.fromarray(puppy).resize((img_size, img_size)))\n","resized_kitten = ToTensor()(Image.fromarray(kitten_cropped).resize((img_size, img_size)))\n","x = torch.stack([resized_puppy, resized_kitten])\n","\n","# Set up a convolutional weights holding 2 filters, each 3x3\n","w = torch.zeros(2, 3, 3, 3, dtype=x.dtype)\n","\n","# The first filter converts the image to grayscale.\n","# Set up the red, green, and blue channels of the filter.\n","w[0, 0, :, :] = torch.tensor([[0, 0, 0], [0, 0.3, 0], [0, 0, 0]])\n","w[0, 1, :, :] = torch.tensor([[0, 0, 0], [0, 0.6, 0], [0, 0, 0]])\n","w[0, 2, :, :] = torch.tensor([[0, 0, 0], [0, 0.1, 0], [0, 0, 0]])\n","\n","# Second filter detects horizontal edges in the blue channel.\n","w[1, 2, :, :] = torch.tensor([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])\n","\n","# Vector of biases. We don't need any bias for the grayscale\n","# filter, but for the edge detection filter we want to add 128\n","# to each output so that nothing is negative.\n","b = torch.tensor([0, 128], dtype=x.dtype)\n","\n","# Compute the result of convolving each input in x with each filter in w,\n","# offsetting by b, and storing the results in out.\n","out, _ = Conv.forward(x, w, b, {'stride': 1, 'pad': 1})\n","\n","def imshow_no_ax(img, normalize=True):\n","  \"\"\" Tiny helper to show images as uint8 and remove axis labels \"\"\"\n","  if normalize:\n","    img_max, img_min = img.max(), img.min()\n","    img = 255.0 * (img - img_min) / (img_max - img_min)\n","  plt.imshow(img)\n","  plt.gca().axis('off')\n","print(out.shape)\n","# Show the original images and the results of the conv operation\n","plt.subplot(2, 3, 1)\n","imshow_no_ax(puppy, normalize=False)\n","plt.title('Original image')\n","plt.subplot(2, 3, 2)\n","imshow_no_ax(out[0, 0])\n","plt.title('Grayscale')\n","plt.subplot(2, 3, 3)\n","imshow_no_ax(out[0, 1])\n","plt.title('Edges')\n","plt.subplot(2, 3, 4)\n","imshow_no_ax(kitten_cropped, normalize=False)\n","plt.subplot(2, 3, 5)\n","imshow_no_ax(out[1, 0])\n","plt.subplot(2, 3, 6)\n","imshow_no_ax(out[1, 1])\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Lqsg-NxHw72y"},"source":["## Convolutional layer: backward\n","Implement the backward pass for the convolution operation in the function `Conv.backward`. Again, you don't need to worry too much about computational efficiency."]},{"cell_type":"code","metadata":{"id":"sPE64kjCqtEz"},"source":["def conv_backward(dout, cache):\n","  \"\"\"\n","  A naive implementation of the backward pass for a convolutional layer.\n","\n","  Inputs:\n","  - dout: Upstream derivatives.\n","  - cache: A tuple of (x, w, b, conv_param) as in conv_forward_naive\n","\n","  Returns a tuple of:\n","  - dx: Gradient with respect to x\n","  - dw: Gradient with respect to w\n","  - db: Gradient with respect to b\n","  \"\"\"\n","  dx, dw, db = None, None, None\n","  #############################################################################\n","  # TODO: Implement the convolutional backward pass.                          #\n","  #############################################################################\n","  # Replace \"pass\" statement with your code\n","  x, w, b, conv_param = cache\n","  dx = \n","  #############################################################################\n","  #                              END OF YOUR CODE                             #\n","  #############################################################################\n","  return dx, dw, db\n","\n","Conv.backward = conv_backward"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"fgj8WovMzYtJ"},"source":["After implementing the convolution backward pass, run the following to test your implementation. You should get errors less than `1e-8`."]},{"cell_type":"code","metadata":{"id":"77NxvIGpw720"},"source":["fix_random_seed(0)\n","x = torch.randn(4, 3, 5, 5, **to_double_cuda)\n","w = torch.randn(2, 3, 3, 3, **to_double_cuda)\n","b = torch.randn(2, **to_double_cuda)\n","dout = torch.randn(4, 2, 5, 5, **to_double_cuda)\n","conv_param = {'stride': 1, 'pad': 1}\n","\n","dx_num = compute_numeric_gradient(lambda x: Conv.forward(x, w, b, conv_param)[0], x, dout)\n","dw_num = compute_numeric_gradient(lambda w: Conv.forward(x, w, b, conv_param)[0], w, dout)\n","db_num = compute_numeric_gradient(lambda b: Conv.forward(x, w, b, conv_param)[0], b, dout)\n","\n","out, cache = Conv.forward(x, w, b, conv_param)\n","dx, dw, db = Conv.backward(dout, cache)\n","\n","print('Testing Conv.backward function')\n","print('dx error: ', rel_error(dx, dx_num))\n","print('dw error: ', rel_error(dw, dw_num))\n","print('db error: ', rel_error(db, db_num))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"CS8EsPacrpG8"},"source":["# Max-pooling"]},{"cell_type":"code","metadata":{"id":"anBWiAVVr24F"},"source":["class MaxPool(object):\n","\n","  @staticmethod\n","  def forward(x, pool_param):\n","    raise NotImplementedError\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    raise NotImplementedError"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"elO_ys-8w723"},"source":["## Max-pooling: forward\n","Implement the forward pass for the max-pooling operation. Again, don't worry too much about computational efficiency."]},{"cell_type":"code","metadata":{"id":"0z5_oQ2PrWCZ"},"source":["def max_pool_forward(x, pool_param):\n","  \"\"\"\n","  A naive implementation of the forward pass for a max-pooling layer.\n","\n","  Inputs:\n","  - x: Input data, of shape (N, C, H, W)\n","  - pool_param: dictionary with the following keys:\n","    - 'pool_height': The height of each pooling region\n","    - 'pool_width': The width of each pooling region\n","    - 'stride': The distance between adjacent pooling regions\n","  No padding is necessary here.\n","\n","  Returns a tuple of:\n","  - out: Output data, of shape (N, C, H', W') where H' and W' are given by\n","    H' = 1 + (H - pool_height) / stride\n","    W' = 1 + (W - pool_width) / stride\n","  - cache: (x, pool_param)\n","  \"\"\"\n","  out = None\n","  #############################################################################\n","  # TODO: Implement the max-pooling forward pass                              #\n","  #############################################################################\n","  # Replace \"pass\" statement with your code\n","  pass\n","  #############################################################################\n","  #                              END OF YOUR CODE                             #\n","  #############################################################################\n","  cache = (x, pool_param)\n","  return out, cache\n","\n","MaxPool.forward = max_pool_forward"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"PeKxeFUN0L8a"},"source":["After implementing the forward pass for max-pooling, run the following to check your implementation. You should get errors less than `1e-7`."]},{"cell_type":"code","metadata":{"id":"qmNJY6E7w724"},"source":["x_shape = torch.tensor((2, 3, 4, 4))\n","x = torch.linspace(-0.3, 0.4, steps=torch.prod(x_shape), **to_double_cuda).reshape(*x_shape)\n","pool_param = {'pool_width': 2, 'pool_height': 2, 'stride': 2}\n","\n","out, _ = MaxPool.forward(x, pool_param)\n","\n","correct_out = torch.tensor([[[[-0.26315789, -0.24842105],\n","                              [-0.20421053, -0.18947368]],\n","                             [[-0.14526316, -0.13052632],\n","                              [-0.08631579, -0.07157895]],\n","                             [[-0.02736842, -0.01263158],\n","                              [ 0.03157895,  0.04631579]]],\n","                            [[[ 0.09052632,  0.10526316],\n","                              [ 0.14947368,  0.16421053]],\n","                             [[ 0.20842105,  0.22315789],\n","                              [ 0.26736842,  0.28210526]],\n","                             [[ 0.32631579,  0.34105263],\n","                              [ 0.38526316,  0.4       ]]]], **to_double_cuda)\n","\n","# Compare your output with ours. Difference should be on the order of e-8.\n","print('Testing MaxPool.forward function:')\n","print('difference: ', rel_error(out, correct_out))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"lLjMhG4nw728"},"source":["## Max-pooling: backward\n","Implement the backward pass for the max-pooling operation. You don't need to worry about computational efficiency."]},{"cell_type":"code","metadata":{"id":"retdcruisTj7"},"source":["def max_pool_backward(dout, cache):\n","  \"\"\"\n","  A naive implementation of the backward pass for a max-pooling layer.\n","  Inputs:\n","  - dout: Upstream derivatives\n","  - cache: A tuple of (x, pool_param) as in the forward pass.\n","  Returns:\n","  - dx: Gradient with respect to x\n","  \"\"\"\n","  dx = None\n","  #############################################################################\n","  # TODO: Implement the max-pooling backward pass                             #\n","  #############################################################################\n","  # Replace \"pass\" statement with your code\n","  pass\n","  #############################################################################\n","  #                              END OF YOUR CODE                             #\n","  #############################################################################\n","  return dx\n","\n","MaxPool.backward = max_pool_backward"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"48x6OP5J0WjS"},"source":["Check your implementation of the max pooling backward pass with numeric gradient checking by running the following. You should get errors less than `1e-10`."]},{"cell_type":"code","metadata":{"id":"9FTLuSsIw729"},"source":["fix_random_seed(0)\n","x = torch.randn(3, 2, 8, 8, **to_double_cuda)\n","dout = torch.randn(3, 2, 4, 4, **to_double_cuda)\n","pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n","\n","dx_num = compute_numeric_gradient(lambda x: MaxPool.forward(x, pool_param)[0], x, dout)\n","\n","out, cache = MaxPool.forward(x, pool_param)\n","dx = MaxPool.backward(dout, cache)\n","\n","print('Testing MaxPool.backward function:')\n","print('dx error: ', rel_error(dx, dx_num))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"0-GA5mHcw73A"},"source":["# Fast layers\n","Making convolution and pooling layers fast can be challenging. To spare you the pain, we've provided fast implementations of the forward and backward passes for convolution and pooling layers.\n","\n","The fast convolution implementation depends on `torch.nn`\n","\n","The API for the fast versions of the convolution and pooling layers is exactly the same as the naive versions that you implemented above: the forward pass receives data, weights, and parameters and produces outputs and a cache object; the backward pass recieves upstream derivatives and the cache object and produces gradients with respect to the data and weights.\n","\n","You can compare the performance of the naive and fast versions of these layers by running the following:"]},{"cell_type":"code","metadata":{"id":"KONf6gRfs7sl"},"source":["class FastConv(object):\n","\n","  @staticmethod\n","  def forward(x, w, b, conv_param):\n","    N, C, H, W = x.shape\n","    F, _, HH, WW = w.shape\n","    stride, pad = conv_param['stride'], conv_param['pad']\n","    layer = torch.nn.Conv2d(C, F, (HH, WW), stride=stride, padding=pad)\n","    layer.weight = torch.nn.Parameter(w)\n","    layer.bias = torch.nn.Parameter(b)\n","    tx = x.detach()\n","    tx.requires_grad = True\n","    out = layer(tx)\n","    cache = (x, w, b, conv_param, tx, out, layer)\n","    return out, cache\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    try:\n","      x, _, _, _, tx, out, layer = cache\n","      out.backward(dout)\n","      dx = tx.grad.detach()\n","      dw = layer.weight.grad.detach()\n","      db = layer.bias.grad.detach()\n","      layer.weight.grad = layer.bias.grad = None\n","    except RuntimeError:\n","      dx, dw, db = torch.zeros_like(tx), torch.zeros_like(layer.weight), torch.zeros_like(layer.bias)\n","    return dx, dw, db\n","\n","\n","class FastMaxPool(object):\n","\n","  @staticmethod\n","  def forward(x, pool_param):\n","    N, C, H, W = x.shape\n","    pool_height, pool_width = pool_param['pool_height'], pool_param['pool_width']\n","    stride = pool_param['stride']\n","    layer = torch.nn.MaxPool2d(kernel_size=(pool_height, pool_width), stride=stride)\n","    tx = x.detach()\n","    tx.requires_grad = True\n","    out = layer(tx)\n","    cache = (x, pool_param, tx, out, layer)\n","    return out, cache\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    try:\n","      x, _, tx, out, layer = cache\n","      out.backward(dout)\n","      dx = tx.grad.detach()\n","    except RuntimeError:\n","      dx = torch.zeros_like(tx)\n","    return dx"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Z7B_QYt206g4"},"source":["We will now compare three different implementations of convolution (both forward and backward):\n","\n","1. Your naive, non-vectorized implementation on CPU\n","2. The fast, vectorized implementation on CPU\n","3. The fast, vectorized implementation on GPU\n","\n","The differences between your implementation and FastConv should be less than `1e-10`. When moving from your implementation to FastConv CPU, you will likely see speedups of at least 100x. When comparing your implementation to FastConv CUDA, you will likely see speedups of more than 500x. (These speedups are not hard requirements for this assignment since we are not asking you to write any vectorized implementations)"]},{"cell_type":"code","metadata":{"id":"mSbc5Ttvw73C"},"source":["# Rel errors should be around e-11 or less\n","fix_random_seed(0)\n","x = torch.randn(10, 3, 31, 31, **to_double)\n","w = torch.randn(25, 3, 3, 3, **to_double)\n","b = torch.randn(25, **to_double)\n","dout = torch.randn(10, 25, 16, 16, **to_double)\n","x_cuda, w_cuda, b_cuda, dout_cuda = x.to('cuda'), w.to('cuda'), b.to('cuda'), dout.to('cuda')\n","conv_param = {'stride': 2, 'pad': 1}\n","\n","t0 = time.time()\n","out_naive, cache_naive = Conv.forward(x, w, b, conv_param)\n","t1 = time.time()\n","out_fast, cache_fast = FastConv.forward(x, w, b, conv_param)\n","t2 = time.time()\n","out_fast_cuda, cache_fast_cuda = FastConv.forward(x_cuda, w_cuda, b_cuda, conv_param)\n","t3 = time.time()\n","\n","print('Testing FastConv.forward:')\n","print('Naive: %fs' % (t1 - t0))\n","print('Fast: %fs' % (t2 - t1))\n","print('Fast CUDA: %fs' % (t3 - t2))\n","print('Speedup: %fx' % ((t1 - t0) / (t2 - t1)))\n","print('Speedup CUDA: %fx' % ((t1 - t0) / (t3 - t2)))\n","print('Difference: ', rel_error(out_naive, out_fast))\n","print('Difference CUDA: ', rel_error(out_naive, out_fast_cuda.to(out_naive.device)))\n","\n","t0 = time.time()\n","dx_naive, dw_naive, db_naive = Conv.backward(dout, cache_naive)\n","t1 = time.time()\n","dx_fast, dw_fast, db_fast = FastConv.backward(dout, cache_fast)\n","t2 = time.time()\n","dx_fast_cuda, dw_fast_cuda, db_fast_cuda = FastConv.backward(dout_cuda, cache_fast_cuda)\n","t3 = time.time()\n","\n","print('\\nTesting FastConv.backward:')\n","print('Naive: %fs' % (t1 - t0))\n","print('Fast: %fs' % (t2 - t1))\n","print('Fast CUDA: %fs' % (t3 - t2))\n","print('Speedup: %fx' % ((t1 - t0) / (t2 - t1)))\n","print('Speedup CUDA: %fx' % ((t1 - t0) / (t3 - t2)))\n","print('dx difference: ', rel_error(dx_naive, dx_fast))\n","print('dw difference: ', rel_error(dw_naive, dw_fast))\n","print('db difference: ', rel_error(db_naive, db_fast))\n","print('dx difference CUDA: ', rel_error(dx_naive, dx_fast_cuda.to(dx_naive.device)))\n","print('dw difference CUDA: ', rel_error(dw_naive, dw_fast_cuda.to(dw_naive.device)))\n","print('db difference CUDA: ', rel_error(db_naive, db_fast_cuda.to(db_naive.device)))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"HdvR1krO2P_q"},"source":["We will now similarly compare your naive implementation of max pooling against the fast implementation. You should see differences of 0 between your implementation and the fast implementation.\n","\n","When comparing your implementation against FastMaxPool on CPU, you will likely see speedups of more than 100x. When comparing your implementation against FastMaxPool on GPU, you will likely see speedups of more than 500x."]},{"cell_type":"code","metadata":{"id":"R0fykwCiw73F"},"source":["# Relative errors should be close to 0.0\n","fix_random_seed(0)\n","x = torch.randn(40, 3, 32, 32, **to_double)\n","dout = torch.randn(40, 3, 16, 16, **to_double)\n","x_cuda, dout_cuda = x.to('cuda'), dout.to('cuda')\n","pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n","\n","t0 = time.time()\n","out_naive, cache_naive = MaxPool.forward(x, pool_param)\n","t1 = time.time()\n","out_fast, cache_fast = FastMaxPool.forward(x, pool_param)\n","t2 = time.time()\n","out_fast_cuda, cache_fast_cuda = FastMaxPool.forward(x_cuda, pool_param)\n","t3 = time.time()\n","\n","print('Testing FastMaxPool.forward:')\n","print('Naive: %fs' % (t1 - t0))\n","print('Fast: %fs' % (t2 - t1))\n","print('Fast CUDA: %fs' % (t3 - t2))\n","print('Speedup: %fx' % ((t1 - t0) / (t2 - t1)))\n","print('Speedup CUDA: %fx' % ((t1 - t0) / (t3 - t2)))\n","print('Difference: ', rel_error(out_naive, out_fast))\n","print('Difference CUDA: ', rel_error(out_naive, out_fast_cuda.to(out_naive.device)))\n","\n","t0 = time.time()\n","dx_naive = MaxPool.backward(dout, cache_naive)\n","t1 = time.time()\n","dx_fast = FastMaxPool.backward(dout, cache_fast)\n","t2 = time.time()\n","dx_fast_cuda = FastMaxPool.backward(dout_cuda, cache_fast_cuda)\n","t3 = time.time()\n","\n","print('\\nTesting FastMaxPool.backward:')\n","print('Naive: %fs' % (t1 - t0))\n","print('Fast: %fs' % (t2 - t1))\n","print('Fast CUDA: %fs' % (t3 - t2))\n","print('Speedup: %fx' % ((t1 - t0) / (t2 - t1)))\n","print('Speedup CUDA: %fx' % ((t1 - t0) / (t3 - t2)))\n","print('dx difference: ', rel_error(dx_naive, dx_fast))\n","print('dx difference CUDA: ', rel_error(dx_naive, dx_fast_cuda.to(dx_naive.device)))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Ix9ih6sKw73I"},"source":["# Convolutional \"sandwich\" layers\n","Previously we introduced the concept of \"sandwich\" layers that combine multiple operations into commonly used patterns. Below you will find sandwich layers that implement a few commonly used patterns for convolutional networks. Run the cells below to sanity check they're working."]},{"cell_type":"code","metadata":{"id":"bx5o2y4Jxx2I"},"source":["class Conv_ReLU(object):\n","\n","  @staticmethod\n","  def forward(x, w, b, conv_param):\n","    \"\"\"\n","    A convenience layer that performs a convolution followed by a ReLU.\n","    Inputs:\n","    - x: Input to the convolutional layer\n","    - w, b, conv_param: Weights and parameters for the convolutional layer\n","    Returns a tuple of:\n","    - out: Output from the ReLU\n","    - cache: Object to give to the backward pass\n","    \"\"\"\n","    a, conv_cache = FastConv.forward(x, w, b, conv_param)\n","    out, relu_cache = ReLU.forward(a)\n","    cache = (conv_cache, relu_cache)\n","    return out, cache\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    \"\"\"\n","    Backward pass for the conv-relu convenience layer.\n","    \"\"\"\n","    conv_cache, relu_cache = cache\n","    da = ReLU.backward(dout, relu_cache)\n","    dx, dw, db = FastConv.backward(da, conv_cache)\n","    return dx, dw, db\n","\n","\n","class Conv_ReLU_Pool(object):\n","\n","  @staticmethod\n","  def forward(x, w, b, conv_param, pool_param):\n","    \"\"\"\n","    A convenience layer that performs a convolution, a ReLU, and a pool.\n","    Inputs:\n","    - x: Input to the convolutional layer\n","    - w, b, conv_param: Weights and parameters for the convolutional layer\n","    - pool_param: Parameters for the pooling layer\n","    Returns a tuple of:\n","    - out: Output from the pooling layer\n","    - cache: Object to give to the backward pass\n","    \"\"\"\n","    a, conv_cache = FastConv.forward(x, w, b, conv_param)\n","    s, relu_cache = ReLU.forward(a)\n","    out, pool_cache = FastMaxPool.forward(s, pool_param)\n","    cache = (conv_cache, relu_cache, pool_cache)\n","    return out, cache\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    \"\"\"\n","    Backward pass for the conv-relu-pool convenience layer\n","    \"\"\"\n","    conv_cache, relu_cache, pool_cache = cache\n","    ds = FastMaxPool.backward(dout, pool_cache)\n","    da = ReLU.backward(ds, relu_cache)\n","    dx, dw, db = FastConv.backward(da, conv_cache)\n","    return dx, dw, db"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"JsWygDZi2tFy"},"source":["Test the implementations of the sandwich layers by running the following. You should see errors less than `1e-7`."]},{"cell_type":"code","metadata":{"id":"B-0DpEY8w73J"},"source":["fix_random_seed(0)\n","x = torch.randn(2, 3, 16, 16, **to_double_cuda)\n","w = torch.randn(3, 3, 3, 3, **to_double_cuda)\n","b = torch.randn(3, **to_double_cuda)\n","dout = torch.randn(2, 3, 8, 8, **to_double_cuda)\n","conv_param = {'stride': 1, 'pad': 1}\n","pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n","\n","out, cache = Conv_ReLU_Pool.forward(x, w, b, conv_param, pool_param)\n","dx, dw, db = Conv_ReLU_Pool.backward(dout, cache)\n","\n","dx_num = compute_numeric_gradient(lambda x: Conv_ReLU_Pool.forward(x, w, b, conv_param, pool_param)[0], x, dout)\n","dw_num = compute_numeric_gradient(lambda w: Conv_ReLU_Pool.forward(x, w, b, conv_param, pool_param)[0], w, dout)\n","db_num = compute_numeric_gradient(lambda b: Conv_ReLU_Pool.forward(x, w, b, conv_param, pool_param)[0], b, dout)\n","\n","# Relative errors should be around e-8 or less\n","print('Testing Conv_ReLU_Pool')\n","print('dx error: ', rel_error(dx_num, dx))\n","print('dw error: ', rel_error(dw_num, dw))\n","print('db error: ', rel_error(db_num, db))"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"WjtyDWxPw73M"},"source":["fix_random_seed(0)\n","x = torch.randn(2, 3, 8, 8, **to_double_cuda)\n","w = torch.randn(3, 3, 3, 3, **to_double_cuda)\n","b = torch.randn(3, **to_double_cuda)\n","dout = torch.randn(2, 3, 8, 8, **to_double_cuda)\n","conv_param = {'stride': 1, 'pad': 1}\n","\n","out, cache = Conv_ReLU.forward(x, w, b, conv_param)\n","dx, dw, db = Conv_ReLU.backward(dout, cache)\n","\n","dx_num = compute_numeric_gradient(lambda x: Conv_ReLU.forward(x, w, b, conv_param)[0], x, dout)\n","dw_num = compute_numeric_gradient(lambda w: Conv_ReLU.forward(x, w, b, conv_param)[0], w, dout)\n","db_num = compute_numeric_gradient(lambda b: Conv_ReLU.forward(x, w, b, conv_param)[0], b, dout)\n","\n","# Relative errors should be around e-8 or less\n","print('Testing Conv_ReLU:')\n","print('dx error: ', rel_error(dx_num, dx))\n","print('dw error: ', rel_error(dw_num, dw))\n","print('db error: ', rel_error(db_num, db))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Kgp7ymihw73P"},"source":["# Three-layer convolutional network\n","Now that you have implemented all the necessary layers, we can put them together into a simple convolutional network.\n","\n","Complete the implementation of the `ThreeLayerConvNet` class. We STRONGLY recommend you to use the fast/sandwich layers (already imported for you) in your implementation. Run the following cells to help you debug:"]},{"cell_type":"code","metadata":{"id":"DIN4bw-R0v0D"},"source":["class ThreeLayerConvNet(object):\n","  \"\"\"\n","  A three-layer convolutional network with the following architecture:\n","  conv - relu - 2x2 max pool - linear - relu - linear - softmax\n","  The network operates on minibatches of data that have shape (N, C, H, W)\n","  consisting of N images, each with height H and width W and with C input\n","  channels.\n","  \"\"\"\n","\n","  def __init__(self, input_dims=(3, 32, 32), num_filters=32, filter_size=7,\n","         hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,\n","         dtype=torch.float, device='cpu'):\n","    \"\"\"\n","    Initialize a new network.\n","    Inputs:\n","    - input_dims: Tuple (C, H, W) giving size of input data\n","    - num_filters: Number of filters to use in the convolutional layer\n","    - filter_size: Width/height of filters to use in the convolutional layer\n","    - hidden_dim: Number of units to use in the fully-connected hidden layer\n","    - num_classes: Number of scores to produce from the final linear layer.\n","    - weight_scale: Scalar giving standard deviation for random initialization\n","      of weights.\n","    - reg: Scalar giving L2 regularization strength\n","    - dtype: A torch data type object; all computations will be performed using\n","      this datatype. float is faster but less accurate, so you should use\n","      double for numeric gradient checking.\n","    - device: device to use for computation. 'cpu' or 'cuda'\n","    \"\"\"\n","    self.params = {}\n","    self.reg = reg\n","    self.dtype = dtype\n","\n","    ############################################################################\n","    # TODO: Initialize weights and biases for the three-layer convolutional    #\n","    # network. Weights should be initialized from a Gaussian centered at 0.0   #\n","    # with standard deviation equal to weight_scale; biases should be          #\n","    # initialized to zero. All weights and biases should be stored in the      #\n","    #  dictionary self.params. Store weights and biases for the convolutional  #\n","    # layer using the keys 'W1' and 'b1'; use keys 'W2' and 'b2' for the       #\n","    # weights and biases of the hidden linear layer, and keys 'W3' and 'b3'    #\n","    # for the weights and biases of the output linear layer.                   #\n","    #                                                                          #\n","    # IMPORTANT: For this assignment, you can assume that the padding          #\n","    # and stride of the first convolutional layer are chosen so that           #\n","    # **the width and height of the input are preserved**. Take a look at      #\n","    # the start of the loss() function to see how that happens.                #               \n","    ############################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    ############################################################################\n","    #                             END OF YOUR CODE                             #\n","    ############################################################################\n","\n","\n","  def loss(self, X, y=None):\n","    \"\"\"\n","    Evaluate loss and gradient for the three-layer convolutional network.\n","    Input / output: Same API as TwoLayerNet.\n","    \"\"\"\n","    X = X.to(self.dtype)\n","    W1, b1 = self.params['W1'], self.params['b1']\n","    W2, b2 = self.params['W2'], self.params['b2']\n","    W3, b3 = self.params['W3'], self.params['b3']\n","\n","    # pass conv_param to the forward pass for the convolutional layer\n","    # Padding and stride chosen to preserve the input spatial size\n","    filter_size = W1.shape[2]\n","    conv_param = {'stride': 1, 'pad': (filter_size - 1) // 2}\n","\n","    # pass pool_param to the forward pass for the max-pooling layer\n","    pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n","\n","    scores = None\n","    ############################################################################\n","    # TODO: Implement the forward pass for the three-layer convolutional net,  #\n","    # computing the class scores for X and storing them in the scores          #\n","    # variable.                                                                #\n","    #                                                                          #\n","    # Remember you can use the functions defined in your implementation above. #\n","    ############################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    ############################################################################\n","    #                             END OF YOUR CODE                             #\n","    ############################################################################\n","\n","    if y is None:\n","      return scores\n","\n","    loss, grads = 0.0, {}\n","    ############################################################################\n","    # TODO: Implement the backward pass for the three-layer convolutional net, #\n","    # storing the loss and gradients in the loss and grads variables. Compute  #\n","    # data loss using softmax, and make sure that grads[k] holds the gradients #\n","    # for self.params[k]. Don't forget to add L2 regularization!               #\n","    #                                                                          #\n","    # NOTE: To ensure that your implementation matches ours and you pass the   #\n","    # automated tests, make sure that your L2 regularization does not include  #\n","    # a factor of 0.5                                                          #\n","    ############################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    ############################################################################\n","    #                             END OF YOUR CODE                             #\n","    ############################################################################\n","\n","    return loss, grads"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"e_MfqAQXw73Q"},"source":["## Sanity check loss\n","After you build a new network, one of the first things you should do is sanity check the loss. When we use the softmax loss, we expect the loss for random weights (and no regularization) to be about `log(C)` for `C` classes. When we add regularization the loss should go up slightly."]},{"cell_type":"code","metadata":{"id":"h-XEWaw2w73R"},"source":["fix_random_seed(0)\n","model = ThreeLayerConvNet(**to_double_cuda)\n","\n","N = 50\n","X = torch.randn(N, 3, 32, 32, **to_double_cuda)\n","y = torch.randint(10, size=(N,), **to_long_cuda)\n","\n","loss, grads = model.loss(X, y)\n","print('Initial loss (no regularization): ', loss.item())\n","\n","model.reg = 0.5\n","loss, grads = model.loss(X, y)\n","print('Initial loss (with regularization): ', loss.item())"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"QEIViSCjw73U"},"source":["## Gradient check\n","After the loss looks reasonable, use numeric gradient checking to make sure that your backward pass is correct. When you use numeric gradient checking you should use a small amount of artificial data and a small number of neurons at each layer.\n","\n","You should see errors less than `1e-5`."]},{"cell_type":"code","metadata":{"id":"xPrOgIsJw73V"},"source":["num_inputs = 2\n","input_dims = (3, 16, 16)\n","reg = 0.0\n","num_classes = 10\n","fix_random_seed(0)\n","X = torch.randn(num_inputs, *input_dims, **to_double_cuda)\n","y = torch.randint(num_classes, size=(num_inputs,), **to_long_cuda)\n","\n","model = ThreeLayerConvNet(num_filters=3, filter_size=3,\n","                          input_dims=input_dims, hidden_dim=7,\n","                          weight_scale=5e-2, **to_double_cuda)\n","loss, grads = model.loss(X, y)\n","\n","for param_name in sorted(grads):\n","    f = lambda _: model.loss(X, y)[0]\n","    param_grad_num = compute_numeric_gradient(f, model.params[param_name])\n","    print('%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name])))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"dUPRjnzww73Y"},"source":["## Overfit small data\n","A nice trick is to train your model with just a few training samples. You should be able to overfit small datasets, which will result in very high training accuracy and comparatively low validation accuracy."]},{"cell_type":"code","metadata":{"id":"pwwQ0XB7w73Z"},"source":["fix_random_seed(0)\n","\n","num_train = 100\n","small_data = {\n","  'X_train': data_dict['X_train'][:num_train],\n","  'y_train': data_dict['y_train'][:num_train],\n","  'X_val': data_dict['X_val'],\n","  'y_val': data_dict['y_val'],\n","}\n","\n","model = ThreeLayerConvNet(weight_scale=1e-3, **to_float_cuda)\n","\n","solver = Solver(model, small_data,\n","                num_epochs=30, batch_size=50,\n","                update_rule=adam,\n","                optim_config={\n","                  'learning_rate': 2e-3,\n","                },\n","                verbose=True, print_every=1,\n","                device='cuda')\n","solver.train()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"KTDOqqdLw73d"},"source":["Plotting the loss, training accuracy, and validation accuracy should show clear overfitting:"]},{"cell_type":"code","metadata":{"id":"fypbffqsw73f"},"source":["plt.title('Training losses')\n","plt.plot(solver.loss_history, 'o')\n","plt.xlabel('iteration')\n","plt.ylabel('loss')\n","plt.gcf().set_size_inches(9, 4)\n","plt.show()\n","\n","plt.title('Train and Val accuracies')\n","plt.plot(solver.train_acc_history, '-o')\n","plt.plot(solver.val_acc_history, '-o')\n","plt.legend(['train', 'val'], loc='upper left')\n","plt.xlabel('epoch')\n","plt.ylabel('accuracy')\n","plt.gcf().set_size_inches(9, 4)\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"W2vnSbfjw73i"},"source":["## Train the net\n","By training the three-layer convolutional network for one epoch, you should achieve greater than 50% accuracy on the training set:"]},{"cell_type":"code","metadata":{"id":"nfArKG-Gw73j"},"source":["fix_random_seed(0)\n","\n","model = ThreeLayerConvNet(weight_scale=0.001, hidden_dim=500, reg=0.001, dtype=torch.float, device='cuda')\n","\n","solver = Solver(model, data_dict,\n","                num_epochs=1, batch_size=64,\n","                update_rule=adam,\n","                optim_config={\n","                  'learning_rate': 2e-3,\n","                },\n","                verbose=True, print_every=50, device='cuda')\n","solver.train()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"vIYQ0nm2w73n"},"source":["## Visualize Filters\n","You can visualize the first-layer convolutional filters from the trained network by running the following:"]},{"cell_type":"code","metadata":{"id":"n3FLipRY4NUv"},"source":["from torchvision.utils import make_grid\n","nrow = math.ceil(math.sqrt(model.params['W1'].shape[0]))\n","grid = make_grid(model.params['W1'], nrow=nrow, padding=1, normalize=True, scale_each=True)\n","plt.imshow(grid.to(device='cpu').permute(1, 2, 0))\n","plt.axis('off')\n","plt.gcf().set_size_inches(5, 5)\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"JleotK9yDcyv"},"source":["# Deep convolutional network\n","Next you will implement a deep convolutional network with an arbitrary number of conv layers in VGGNet style.\n","\n","Read through the `DeepConvNet` class.\n","\n","Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing batch normalization; we will add those features soon. Again, we STRONGLY recommend you to use the fast/sandwich layers (already imported for you) in your implementation."]},{"cell_type":"code","metadata":{"id":"Ah-_nwx2BSxl"},"source":["class DeepConvNet(object):\n","  \"\"\"\n","  A convolutional neural network with an arbitrary number of convolutional\n","  layers in VGG-Net style. All convolution layers will use kernel size 3 and \n","  padding 1 to preserve the feature map size, and all pooling layers will be\n","  max pooling layers with 2x2 receptive fields and a stride of 2 to halve the\n","  size of the feature map.\n","\n","  The network will have the following architecture:\n","  \n","  {conv - [batchnorm?] - relu - [pool?]} x (L - 1) - linear\n","\n","  Each {...} structure is a \"macro layer\" consisting of a convolution layer,\n","  an optional batch normalization layer, a ReLU nonlinearity, and an optional\n","  pooling layer. After L-1 such macro layers, a single fully-connected layer\n","  is used to predict the class scores.\n","\n","  The network operates on minibatches of data that have shape (N, C, H, W)\n","  consisting of N images, each with height H and width W and with C input\n","  channels.\n","  \"\"\"\n","  def __init__(self, input_dims=(3, 32, 32),\n","               num_filters=[8, 8, 8, 8, 8],\n","               max_pools=[0, 1, 2, 3, 4],\n","               batchnorm=False,\n","               num_classes=10, weight_scale=1e-3, reg=0.0,\n","               weight_initializer=None,\n","               dtype=torch.float, device='cpu'):\n","    \"\"\"\n","    Initialize a new network.\n","\n","    Inputs:\n","    - input_dims: Tuple (C, H, W) giving size of input data\n","    - num_filters: List of length (L - 1) giving the number of convolutional\n","      filters to use in each macro layer.\n","    - max_pools: List of integers giving the indices of the macro layers that\n","      should have max pooling (zero-indexed).\n","    - batchnorm: Whether to include batch normalization in each macro layer\n","    - num_classes: Number of scores to produce from the final linear layer.\n","    - weight_scale: Scalar giving standard deviation for random initialization\n","      of weights, or the string \"kaiming\" to use Kaiming initialization instead\n","    - reg: Scalar giving L2 regularization strength. L2 regularization should\n","      only be applied to convolutional and fully-connected weight matrices;\n","      it should not be applied to biases or to batchnorm scale and shifts.\n","    - dtype: A torch data type object; all computations will be performed using\n","      this datatype. float is faster but less accurate, so you should use\n","      double for numeric gradient checking.\n","    - device: device to use for computation. 'cpu' or 'cuda'    \n","    \"\"\"\n","    self.params = {}\n","    self.num_layers = len(num_filters)+1\n","    self.max_pools = max_pools\n","    self.batchnorm = batchnorm\n","    self.reg = reg\n","    self.dtype = dtype\n","  \n","    if device == 'cuda':\n","      device = 'cuda:0'\n","    \n","    ############################################################################\n","    # TODO: Initialize the parameters for the DeepConvNet. All weights,        #\n","    # biases, and batchnorm scale and shift parameters should be stored in the #\n","    # dictionary self.params.                                                  #\n","    #                                                                          #\n","    # Weights for conv and fully-connected layers should be initialized        #\n","    # according to weight_scale. Biases should be initialized to zero.         #\n","    # Batchnorm scale (gamma) and shift (beta) parameters should be initilized #\n","    # to ones and zeros respectively.                                          #           \n","    ############################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    ############################################################################\n","    #                             END OF YOUR CODE                             #\n","    ############################################################################\n","\n","    # With batch normalization we need to keep track of running means and\n","    # variances, so we need to pass a special bn_param object to each batch\n","    # normalization layer. You should pass self.bn_params[0] to the forward pass\n","    # of the first batch normalization layer, self.bn_params[1] to the forward\n","    # pass of the second batch normalization layer, etc.\n","    self.bn_params = []\n","    if self.batchnorm:\n","      self.bn_params = [{'mode': 'train'} for _ in range(len(num_filters))]\n","      \n","    # Check that we got the right number of parameters\n","    if not self.batchnorm:\n","      params_per_macro_layer = 2  # weight and bias\n","    else:\n","      params_per_macro_layer = 4  # weight, bias, scale, shift\n","    num_params = params_per_macro_layer * len(num_filters) + 2\n","    msg = 'self.params has the wrong number of elements. Got %d; expected %d'\n","    msg = msg % (len(self.params), num_params)\n","    assert len(self.params) == num_params, msg\n","\n","    # Check that all parameters have the correct device and dtype:\n","    for k, param in self.params.items():\n","      msg = 'param \"%s\" has device %r; should be %r' % (k, param.device, device)\n","      assert param.device == torch.device(device), msg\n","      msg = 'param \"%s\" has dtype %r; should be %r' % (k, param.dtype, dtype)\n","      assert param.dtype == dtype, msg\n","\n","  def loss(self, X, y=None):\n","    \"\"\"\n","    Evaluate loss and gradient for the deep convolutional network.\n","    Input / output: Same API as ThreeLayerConvNet.\n","    \"\"\"\n","    X = X.to(self.dtype)\n","    mode = 'test' if y is None else 'train'\n","\n","    # Set train/test mode for batchnorm params since they\n","    # behave differently during training and testing.\n","    if self.batchnorm:\n","      for bn_param in self.bn_params:\n","        bn_param['mode'] = mode\n","    scores = None\n","\n","    # pass conv_param to the forward pass for the convolutional layer\n","    # Padding and stride chosen to preserve the input spatial size\n","    filter_size = 3\n","    conv_param = {'stride': 1, 'pad': (filter_size - 1) // 2}\n","\n","    # pass pool_param to the forward pass for the max-pooling layer\n","    pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n","\n","    scores = None\n","    ############################################################################\n","    # TODO: Implement the forward pass for the DeepConvNet, computing the      #\n","    # class scores for X and storing them in the scores variable.              #\n","    #                                                                          #\n","    # You should use the fast versions of convolution and max pooling layers,  #\n","    # or the convolutional sandwich layers, to simplify your implementation.   #\n","    ############################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    ############################################################################\n","    #                             END OF YOUR CODE                             #\n","    ############################################################################\n","\n","    if y is None:\n","      return scores\n","\n","    loss, grads = 0, {}\n","    ############################################################################\n","    # TODO: Implement the backward pass for the DeepConvNet, storing the loss  #\n","    # and gradients in the loss and grads variables. Compute data loss using   #\n","    # softmax, and make sure that grads[k] holds the gradients for             #\n","    # self.params[k]. Don't forget to add L2 regularization!                   #\n","    #                                                                          #\n","    # NOTE: To ensure that your implementation matches ours and you pass the   #\n","    # automated tests, make sure that your L2 regularization does not include  #\n","    # a factor of 0.5                                                          #\n","    ############################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    ############################################################################\n","    #                             END OF YOUR CODE                             #\n","    ############################################################################\n","\n","    return loss, grads"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"0AC0R6dv059E"},"source":["## Sanity check loss\n","After you build a new network, one of the first things you should do is sanity check the loss. When we use the softmax loss, we expect the loss for random weights (and no regularization) to be about `log(C)` for `C` classes. When we add regularization the loss should go up slightly."]},{"cell_type":"code","metadata":{"id":"MPfK4L5P059L"},"source":["fix_random_seed(0)\n","input_dims = (3, 32, 32)\n","model = DeepConvNet(num_filters=[8, 64], max_pools=[0, 1], **to_double_cuda)\n","\n","N = 50\n","X = torch.randn(N, *input_dims, **to_double_cuda)\n","y = torch.randint(10, size=(N,), **to_long_cuda)\n","\n","loss, grads = model.loss(X, y)\n","print('Initial loss (no regularization): ', loss.item())\n","\n","model.reg = 1.\n","loss, grads = model.loss(X, y)\n","print('Initial loss (with regularization): ', loss.item())"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"8BfRDkEj1TX8"},"source":["## Gradient check\n","After the loss looks reasonable, use numeric gradient checking to make sure that your backward pass is correct. When you use numeric gradient checking you should use a small amount of artifical data and a small number of neurons at each layer.\n","\n","For the check with reg=0, you should see relative errors less than `1e-5`. For the check with reg=3.14, you should see relative errors less than `1e-4`"]},{"cell_type":"code","metadata":{"id":"qiPiP1X11TYA"},"source":["num_inputs = 2\n","input_dims = (3, 8, 8)\n","num_classes = 10\n","fix_random_seed(0)\n","X = torch.randn(num_inputs, *input_dims, **to_double_cuda)\n","y = torch.randint(num_classes, size=(num_inputs,), **to_long_cuda)\n","\n","for reg in [0, 3.14]:\n","  print('Running check with reg = ', reg)\n","  model = DeepConvNet(input_dims=input_dims, num_classes=num_classes,\n","                      num_filters=[8, 8, 8],\n","                      max_pools=[0, 2],\n","                      reg=reg,\n","                      weight_scale=5e-2, **to_double_cuda)\n","\n","  loss, grads = model.loss(X, y)\n","  # The relative errors should be up to the order of e-6\n","  for name in sorted(grads):\n","    f = lambda _: model.loss(X, y)[0]\n","    grad_num = compute_numeric_gradient(f, model.params[name])\n","    print('%s max relative error: %e' % (name, rel_error(grad_num, grads[name])))\n","  if reg == 0: print()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"1_njNfEh3cxs"},"source":["## Overfit small data\n","As another sanity check, make sure you can overfit a small dataset of 50 images. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 30 epochs."]},{"cell_type":"code","metadata":{"id":"2NccCDJ3e1DR"},"source":["# TODO: Use a DeepConvNet to overfit 50 training examples by \n","# tweaking just the learning rate and initialization scale.\n","fix_random_seed(0)\n","\n","num_train = 50\n","small_data = {\n","  'X_train': data_dict['X_train'][:num_train],\n","  'y_train': data_dict['y_train'][:num_train],\n","  'X_val': data_dict['X_val'],\n","  'y_val': data_dict['y_val'],\n","}\n","input_dims = small_data['X_train'].shape[1:]\n","\n","weight_scale = 2e-3   # Experiment with this!\n","learning_rate = 1e-5  # Experiment with this!\n","############################################################################\n","# TODO: Change weight_scale and learning_rate so your model achieves 100%  #\n","# training accuracy within 30 epochs.                                      #\n","############################################################################\n","# Replace \"pass\" statement with your code\n","pass\n","############################################################################\n","#                             END OF YOUR CODE                             #\n","############################################################################\n","model = DeepConvNet(input_dims=input_dims, num_classes=10,\n","                    num_filters=[8, 16, 32, 64],\n","                    max_pools=[0, 1, 2, 3],\n","                    reg=1e-5, weight_scale=weight_scale, **to_float_cuda)\n","solver = Solver(model, small_data,\n","                print_every=10, num_epochs=30, batch_size=10,\n","                update_rule=adam,\n","                optim_config={\n","                  'learning_rate': learning_rate,\n","                },\n","                device='cuda',\n","         )\n","solver.train()\n","\n","plt.plot(solver.loss_history, 'o')\n","plt.title('Training loss history')\n","plt.xlabel('Iteration')\n","plt.ylabel('Training loss')\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"FI3LznMXRnad"},"source":["# Kaiming initialization\n","So far, you manually tuned the weight scale and for weight initialization.\n","However, this is inefficient when it comes to training deep neural networks; practically, as your weight matrix is larger, the weight scale should be small.\n","Below you will implement [Kaiming initialization](http://arxiv-web3.library.cornell.edu/abs/1502.01852). For more details, refer to [cs231n note](http://cs231n.github.io/neural-networks-2/#init) and [PyTorch documentation](https://pytorch.org/docs/stable/nn.init.html#torch.nn.init.kaiming_normal_)."]},{"cell_type":"code","metadata":{"id":"y90Z6I18AdjW"},"source":["def kaiming_initializer(Din, Dout, K=None, relu=True, device='cpu',\n","                        dtype=torch.float32):\n","  \"\"\"\n","  Implement Kaiming initialization for linear and convolution layers.\n","  \n","  Inputs:\n","  - Din, Dout: Integers giving the number of input and output dimensions for\n","    this layer\n","  - K: If K is None, then initialize weights for a linear layer with Din input\n","    dimensions and Dout output dimensions. Otherwise if K is a nonnegative\n","    integer then initialize the weights for a convolution layer with Din input\n","    channels, Dout output channels, and a kernel size of KxK.\n","  - relu: If ReLU=True, then initialize weights with a gain of 2 to account for\n","    a ReLU nonlinearity (Kaiming initializaiton); otherwise initialize weights\n","    with a gain of 1 (Xavier initialization).\n","  - device, dtype: The device and datatype for the output tensor.\n","\n","  Returns:\n","  - weight: A torch Tensor giving initialized weights for this layer. For a\n","    linear layer it should have shape (Din, Dout); for a convolution layer it\n","    should have shape (Dout, Din, K, K).\n","  \"\"\"\n","  gain = 2. if relu else 1.\n","  weight = None\n","  if K is None:\n","    ###########################################################################\n","    # TODO: Implement Kaiming initialization for linear layer.                #\n","    # The weight scale is sqrt(gain / fan_in),                                #\n","    # where gain is 2 if ReLU is followed by the layer, or 1 if not,          #\n","    # and fan_in = num_in_channels (= Din).                                   #\n","    # The output should be a tensor in the designated size, dtype, and device.#\n","    ###########################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    ###########################################################################\n","    #                            END OF YOUR CODE                             #\n","    ###########################################################################\n","  else:\n","    ###########################################################################\n","    # TODO: Implement Kaiming initialization for convolutional layer.         #\n","    # The weight scale is sqrt(gain / fan_in),                                #\n","    # where gain is 2 if ReLU is followed by the layer, or 1 if not,          #\n","    # and fan_in = num_in_channels (= Din) * K * K                            #\n","    # The output should be a tensor in the designated size, dtype, and device.#\n","    ###########################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    ###########################################################################\n","    #                            END OF YOUR CODE                             #\n","    ###########################################################################\n","  return weight    "],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"XkZL_lsufSVZ"},"source":["# Convolutional nets with Kaiming initialization\n","Now that you have a working implementation for Kaiming initialization, go back to your [`DeepConvnet`](#scrollTo=Ah-_nwx2BSxl). Modify your implementation to add Kaiming initialization.\n","\n","Concretely, when the `weight_scale` is set to `'kaiming'` in the constructor, you should initialize weights of convolutional and linear layers using `kaiming_initializer`. Once you are done, run the following to see the effect of kaiming initialization in deep CNNs.\n","\n","In this experiment, we train a 31-layer network with four different weight initialization schemes. Among them, only the Kaiming initialization method should achieve a non-random accuracy after one epoch of training.\n","\n","You may see `nan` loss when `weight_scale` is large, this shows a catastrophe of inappropriate weight initialization."]},{"cell_type":"code","metadata":{"id":"sQJKcH60jfTm"},"source":["fix_random_seed(0)\n","\n","# Try training a deep convolutional net with different weight initialization methods\n","num_train = 10000\n","small_data = {\n","  'X_train': data_dict['X_train'][:num_train],\n","  'y_train': data_dict['y_train'][:num_train],\n","  'X_val': data_dict['X_val'],\n","  'y_val': data_dict['y_val'],\n","}\n","input_dims = data_dict['X_train'].shape[1:]\n","\n","weight_scales = ['kaiming', 1e-1, 1e-2, 1e-3]\n","\n","solvers = []\n","for weight_scale in weight_scales:\n","  print('Solver with weight scale: ', weight_scale)\n","  model = DeepConvNet(input_dims=input_dims, num_classes=10,\n","                      num_filters=([8] * 10) + ([32] * 10) + ([128] * 10),\n","                      max_pools=[9, 19],\n","                      weight_scale=weight_scale,\n","                      reg=1e-5, **to_float_cuda)\n","\n","  solver = Solver(model, small_data,\n","                  num_epochs=1, batch_size=128,\n","                  update_rule=sgd_momentum,\n","                  optim_config={\n","                    'learning_rate': 2e-3,\n","                  },\n","                  print_every=20, device='cuda')\n","  solver.train()\n","  solvers.append(solver)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"6WDM0E5lHBmD"},"source":["def plot_training_history_init(title, xlabel, solvers, labels, plot_fn, marker='-o'):\n","  plt.title(title)\n","  plt.xlabel(xlabel)\n","  for solver, label in zip(solvers, labels):    \n","    data = plot_fn(solver)\n","    label = 'weight_scale=' + str(label)\n","    plt.plot(data, marker, label=label)\n","  plt.legend(loc='lower center', ncol=len(solvers))"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"uG-dQDRCH_XD"},"source":["plt.subplot(3, 1, 1)\n","plot_training_history_init('Training loss','Iteration', solvers, weight_scales,\n","                            lambda x: x.loss_history, marker='o')\n","plt.subplot(3, 1, 2)\n","plot_training_history_init('Training accuracy','Epoch', solvers, weight_scales,\n","                           lambda x: x.train_acc_history)\n","plt.subplot(3, 1, 3)\n","plot_training_history_init('Validation accuracy','Epoch', solvers, weight_scales,\n","                           lambda x: x.val_acc_history)\n","plt.gcf().set_size_inches(15, 15)\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"ogx_-gJ1e1EO"},"source":["# Train a good model!\n","Train the best convolutional model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 72% accuracy on the validation set using a convolutional net, within 60 seconds of training.\n","\n","You might find it useful to use batch normalization in your model. However, since we do not ask you to implement it CUDA-friendly, it might slow down training.\n","\n","Hint: Your model does not have to be too deep.\n","\n","Hint 2: We used `batch_size = 128` for training a model with 76% validation accuracy. You don't have to follow this, but it would save your time for hyperparameter search."]},{"cell_type":"code","metadata":{"id":"UPRQvUDJe1EQ"},"source":["input_dims = data_dict['X_train'].shape[1:]\n","torch.backends.cudnn.deterministic = True\n","torch.backends.cudnn.benchmark = True\n","\n","model = None\n","solver = None\n","################################################################################\n","# TODO: Train the best DeepConvNet that you can on CIFAR-10 within 60 seconds. #\n","################################################################################\n","# Replace \"pass\" statement with your code\n","pass\n","################################################################################\n","#                              END OF YOUR CODE                                #\n","################################################################################\n","solver.train(time_limit=60)\n","\n","torch.backends.cudnn.benchmark = False"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"uZWeaN-6e1ET"},"source":["# Test your model!\n","Run your best model on the validation and test sets. You should achieve above 72% accuracy on the validation set and 70% accuracy on the test set.\n","\n","(Our best model gets 76% validation accuracy and 75% test accuracy -- can you beat ours?)\n"]},{"cell_type":"code","metadata":{"id":"xdVs_GEse1EU"},"source":["print('Validation set accuracy: ', solver.check_accuracy(data_dict['X_val'], data_dict['y_val']))\n","print('Test set accuracy: ', solver.check_accuracy(data_dict['X_test'], data_dict['y_test']))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"KqsqNYOVwypM","tags":["pdf-title"]},"source":["# Batch Normalization\n","One way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. \n","One idea along these lines is batch normalization which was proposed by [1] in 2015.\n","\n","The idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n","\n","The authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [1] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n","\n","It is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n","\n","[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n","Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"]},{"cell_type":"code","metadata":{"id":"EbSBc8mt4so0"},"source":["class BatchNorm(object):\n","\n","  @staticmethod\n","  def forward(x, gamma, beta, bn_param):\n","    raise NotImplementedError\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    raise NotImplementedError\n","\n","  @staticmethod\n","  def backward_alt(dout, cache):\n","    raise NotImplementedError"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"s0ELNJIlwypX"},"source":["## Batch normalization: forward\n","Implement the batch normalization forward pass in the function `BatchNorm.forward`. Once you have done so, run the following to test your implementation.\n","\n","Referencing the paper linked to above in [1] may be helpful!"]},{"cell_type":"code","metadata":{"id":"LhULDxfU43f1"},"source":["def batchnorm_forward(x, gamma, beta, bn_param):\n","  \"\"\"\n","  Forward pass for batch normalization.\n","\n","  During training the sample mean and (uncorrected) sample variance are\n","  computed from minibatch statistics and used to normalize the incoming data.\n","  During training we also keep an exponentially decaying running mean of the\n","  mean and variance of each feature, and these averages are used to normalize\n","  data at test-time.\n","\n","  At each timestep we update the running averages for mean and variance using\n","  an exponential decay based on the momentum parameter:\n","\n","  running_mean = momentum * running_mean + (1 - momentum) * sample_mean\n","  running_var = momentum * running_var + (1 - momentum) * sample_var\n","\n","  Note that the batch normalization paper suggests a different test-time\n","  behavior: they compute sample mean and variance for each feature using a\n","  large number of training images rather than using a running average. For\n","  this implementation we have chosen to use running averages instead since\n","  they do not require an additional estimation step; the PyTorch\n","  implementation of batch normalization also uses running averages.\n","\n","  Input:\n","  - x: Data of shape (N, D)\n","  - gamma: Scale parameter of shape (D,)\n","  - beta: Shift paremeter of shape (D,)\n","  - bn_param: Dictionary with the following keys:\n","    - mode: 'train' or 'test'; required\n","    - eps: Constant for numeric stability\n","    - momentum: Constant for running mean / variance.\n","    - running_mean: Array of shape (D,) giving running mean of features\n","    - running_var Array of shape (D,) giving running variance of features\n","\n","  Returns a tuple of:\n","  - out: of shape (N, D)\n","  - cache: A tuple of values needed in the backward pass\n","  \"\"\"\n","  mode = bn_param['mode']\n","  eps = bn_param.get('eps', 1e-5)\n","  momentum = bn_param.get('momentum', 0.9)\n","\n","  N, D = x.shape\n","  running_mean = bn_param.get('running_mean', torch.zeros(D, dtype=x.dtype, device=x.device))\n","  running_var = bn_param.get('running_var', torch.zeros(D, dtype=x.dtype, device=x.device))\n","\n","  out, cache = None, None\n","  if mode == 'train':\n","    #######################################################################\n","    # TODO: Implement the training-time forward pass for batch norm.      #\n","    # Use minibatch statistics to compute the mean and variance, use      #\n","    # these statistics to normalize the incoming data, and scale and      #\n","    # shift the normalized data using gamma and beta.                     #\n","    #                                                                     #\n","    # You should store the output in the variable out. Any intermediates  #\n","    # that you need for the backward pass should be stored in the cache   #\n","    # variable.                                                           #\n","    #                                                                     #\n","    # You should also use your computed sample mean and variance together #\n","    # with the momentum variable to update the running mean and running   #\n","    # variance, storing your result in the running_mean and running_var   #\n","    # variables.                                                          #\n","    #                                                                     #\n","    # Note that though you should be keeping track of the running         #\n","    # variance, you should normalize the data based on the standard       #\n","    # deviation (square root of variance) instead!                        # \n","    # Referencing the original paper (https://arxiv.org/abs/1502.03167)   #\n","    # might prove to be helpful.                                          #\n","    #######################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    #######################################################################\n","    #                           END OF YOUR CODE                          #\n","    #######################################################################\n","  elif mode == 'test':\n","    #######################################################################\n","    # TODO: Implement the test-time forward pass for batch normalization. #\n","    # Use the running mean and variance to normalize the incoming data,   #\n","    # then scale and shift the normalized data using gamma and beta.      #\n","    # Store the result in the out variable.                               #\n","    #######################################################################\n","    # Replace \"pass\" statement with your code\n","    pass\n","    #######################################################################\n","    #                           END OF YOUR CODE                          #\n","    #######################################################################\n","  else:\n","    raise ValueError('Invalid forward batchnorm mode \"%s\"' % mode)\n","\n","  # Store the updated running means back into bn_param\n","  bn_param['running_mean'] = running_mean.detach()\n","  bn_param['running_var'] = running_var.detach()\n","\n","  return out, cache\n","\n","BatchNorm.forward = batchnorm_forward"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"q9cFW4heSrpt"},"source":["After implementing the forward pass for batch normalization, you can run the following to sanity check your implementation. After running batch normalization with beta=0 and gamma=1, the data should have zero mean and unit variance.\n","\n","After running batch normalization with nontrivial beta and gamma, the output data should have mean approximately equal to beta, and std approximatly equal to gamma."]},{"cell_type":"code","metadata":{"id":"7iB1mAkLwypZ"},"source":["# Check the training-time forward pass by checking means and variances\n","# of features both before and after batch normalization   \n","def print_mean_std(x,dim=0):\n","  means = ['%.3f' % xx for xx in x.mean(dim=dim).tolist()]\n","  stds = ['%.3f' % xx for xx in x.std(dim=dim).tolist()]\n","  print('  means: ', means)\n","  print('  stds:  ', stds)\n","  print()\n","\n","# Simulate the forward pass for a two-layer network\n","fix_random_seed(0)\n","N, D1, D2, D3 = 200, 50, 60, 3\n","X = torch.randn(N, D1, **to_double_cuda)\n","W1 = torch.randn(D1, D2, **to_double_cuda)\n","W2 = torch.randn(D2, D3, **to_double_cuda)\n","a = X.matmul(W1).clamp(min=0.).matmul(W2)\n","\n","print('Before batch normalization:')\n","print_mean_std(a,dim=0)\n","\n","# Run with gamma=1, beta=0. Means should be close to zero and stds close to one\n","gamma = torch.ones(D3, **to_double_cuda)\n","beta = torch.zeros(D3, **to_double_cuda)\n","print('After batch normalization (gamma=1, beta=0)')\n","a_norm, _ = BatchNorm.forward(a, gamma, beta, {'mode': 'train'})\n","print_mean_std(a_norm,dim=0)\n","\n","# Run again with nontrivial gamma and beta. Now means should be close to beta\n","# and std should be close to gamma.\n","gamma = torch.tensor([1.0, 2.0, 3.0], **to_double_cuda)\n","beta = torch.tensor([11.0, 12.0, 13.0], **to_double_cuda)\n","print('After batch normalization (gamma=', gamma.tolist(), ', beta=', beta.tolist(), ')')\n","a_norm, _ = BatchNorm.forward(a, gamma, beta, {'mode': 'train'})\n","print_mean_std(a_norm,dim=0)"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"qGUPz4t_Tam4"},"source":["We can sanity-check the test-time forward pass of batch normalization by running the following. First we run the training-time forward pass many times to \"warm up\" the running averages. If we then run a test-time forward pass, the output should have approximately zero mean and unit variance."]},{"cell_type":"code","metadata":{"id":"w8lPQyI9wype"},"source":["fix_random_seed(0)\n","N, D1, D2, D3 = 200, 50, 60, 3\n","W1 = torch.randn(D1, D2, **to_double_cuda)\n","W2 = torch.randn(D2, D3, **to_double_cuda)\n","\n","bn_param = {'mode': 'train'}\n","gamma = torch.ones(D3, **to_double_cuda)\n","beta = torch.zeros(D3, **to_double_cuda)\n","\n","for t in range(500):\n","  X = torch.randn(N, D1, **to_double_cuda)\n","  a = X.matmul(W1).clamp(min=0.).matmul(W2)\n","  BatchNorm.forward(a, gamma, beta, bn_param)\n","\n","bn_param['mode'] = 'test'\n","X = torch.randn(N, D1, **to_double_cuda)\n","a = X.matmul(W1).clamp(min=0.).matmul(W2)\n","a_norm, _ = BatchNorm.forward(a, gamma, beta, bn_param)\n","\n","# Means should be close to zero and stds close to one, but will be\n","# noisier than training-time forward passes.\n","print('After batch normalization (test-time):')\n","print_mean_std(a_norm,dim=0)"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"jt0hsHxIwypj"},"source":["## Batch normalization: backward\n","Now implement the backward pass for batch normalization in the function `BatchNorm.backward`.\n","\n","To derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n","\n","Please don't forget to implement the train and test mode separately.\n","\n","Once you have finished, run the following to numerically check your backward pass."]},{"cell_type":"code","metadata":{"id":"HpjnmV8D6e0Y"},"source":["def batchnorm_backward(dout, cache):\n","  \"\"\"\n","  Backward pass for batch normalization.\n","\n","  For this implementation, you should write out a computation graph for\n","  batch normalization on paper and propagate gradients backward through\n","  intermediate nodes.\n","\n","  Inputs:\n","  - dout: Upstream derivatives, of shape (N, D)\n","  - cache: Variable of intermediates from batchnorm_forward.\n","\n","  Returns a tuple of:\n","  - dx: Gradient with respect to inputs x, of shape (N, D)\n","  - dgamma: Gradient with respect to scale parameter gamma, of shape (D,)\n","  - dbeta: Gradient with respect to shift parameter beta, of shape (D,)\n","  \"\"\"\n","  dx, dgamma, dbeta = None, None, None\n","  ###########################################################################\n","  # TODO: Implement the backward pass for batch normalization. Store the    #\n","  # results in the dx, dgamma, and dbeta variables.                         #\n","  # Referencing the original paper (https://arxiv.org/abs/1502.03167)       #\n","  # might prove to be helpful.                                              #\n","  # Don't forget to implement train and test mode separately.               #\n","  ###########################################################################\n","  # Replace \"pass\" statement with your code\n","  pass\n","  ###########################################################################\n","  #                             END OF YOUR CODE                            #\n","  ###########################################################################\n","\n","  return dx, dgamma, dbeta\n","\n","BatchNorm.backward = batchnorm_backward"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"n2pMzvTqwypk"},"source":["# Gradient check batchnorm backward pass\n","fix_random_seed(0)\n","N, D = 4, 5\n","x = 5 * torch.randn(N, D, **to_double_cuda) + 12\n","gamma = torch.randn(D, **to_double_cuda)\n","beta = torch.randn(D, **to_double_cuda)\n","dout = torch.randn(N, D, **to_double_cuda)\n","\n","bn_param = {'mode': 'train'}\n","fx = lambda x: BatchNorm.forward(x, gamma, beta, bn_param)[0]\n","fg = lambda a: BatchNorm.forward(x, a, beta, bn_param)[0]\n","fb = lambda b: BatchNorm.forward(x, gamma, b, bn_param)[0]\n","\n","dx_num = compute_numeric_gradient(fx, x, dout)\n","da_num = compute_numeric_gradient(fg, gamma.clone(), dout)\n","db_num = compute_numeric_gradient(fb, beta.clone(), dout)\n","\n","_, cache = BatchNorm.forward(x, gamma, beta, bn_param)\n","dx, dgamma, dbeta = BatchNorm.backward(dout, cache)\n","# You should expect to see relative errors between 1e-12 and 1e-9\n","print('dx error: ', rel_error(dx_num, dx))\n","print('dgamma error: ', rel_error(da_num, dgamma))\n","print('dbeta error: ', rel_error(db_num, dbeta))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"hFxuZMUAwypp"},"source":["## Batch normalization: alternative backward\n","In class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n","\n","Surprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too!  \n","\n","In the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n","\n","we first calculate the mean $\\mu$ and variance $v$.\n","With $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$  and normalized data $Y$.\n","The equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n","\n","\\begin{align}\n","& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k  &  v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n","& \\sigma=\\sqrt{v+\\epsilon}         &  y_i=\\frac{x_i-\\mu}{\\sigma}\n","\\end{align}"]},{"cell_type":"markdown","metadata":{"id":"gVoopiQ7wypr"},"source":["<img src=\"https://web.eecs.umich.edu/~justincj/teaching/eecs498/assets/a3/batchnorm_graph.png\" width=691 height=202>"]},{"cell_type":"markdown","metadata":{"id":"EDTJ6AXawypt","tags":["pdf-ignore"]},"source":["The meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n","\n","The unknown/hart part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at \n","$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n","$\\frac{\\partial \\sigma}{\\partial v}$, \n","$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\n","and then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n","\n","If it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. \n","\n","You should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation. \n","\n","After doing so, implement the simplified batch normalization backward pass in the function `BatchNorm.backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster."]},{"cell_type":"code","metadata":{"id":"zTh1EemM7MD3"},"source":["def batchnorm_backward_alt(dout, cache):\n","  \"\"\"\n","  Alternative backward pass for batch normalization.\n","  For this implementation you should work out the derivatives for the batch\n","  normalizaton backward pass on paper and simplify as much as possible. You\n","  should be able to derive a simple expression for the backward pass. \n","  See the jupyter notebook for more hints.\n","   \n","  Note: This implementation should expect to receive the same cache variable\n","  as batchnorm_backward, but might not use all of the values in the cache.\n","\n","  Inputs / outputs: Same as batchnorm_backward\n","  \"\"\"\n","  dx, dgamma, dbeta = None, None, None\n","  ###########################################################################\n","  # TODO: Implement the backward pass for batch normalization. Store the    #\n","  # results in the dx, dgamma, and dbeta variables.                         #\n","  #                                                                         #\n","  # After computing the gradient with respect to the centered inputs, you   #\n","  # should be able to compute gradients with respect to the inputs in a     #\n","  # single statement; our implementation fits on a single 80-character line.#\n","  ###########################################################################\n","  # Replace \"pass\" statement with your code\n","  pass\n","  ###########################################################################\n","  #                             END OF YOUR CODE                            #\n","  ###########################################################################\n","\n","  return dx, dgamma, dbeta\n","\n","BatchNorm.backward_alt = batchnorm_backward_alt"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"cJZp2i7ywypv"},"source":["fix_random_seed(0)\n","N, D = 128, 2048\n","x = 5 * torch.randn(N, D, **to_double_cuda) + 12\n","gamma = torch.randn(D, **to_double_cuda)\n","beta = torch.randn(D, **to_double_cuda)\n","dout = torch.randn(N, D, **to_double_cuda)\n","\n","bn_param = {'mode': 'train'}\n","out, cache = BatchNorm.forward(x, gamma, beta, bn_param)\n","\n","t1 = time.time()\n","dx1, dgamma1, dbeta1 = BatchNorm.backward(dout, cache)\n","t2 = time.time()\n","dx2, dgamma2, dbeta2 = BatchNorm.backward_alt(dout, cache)\n","t3 = time.time()\n","\n","print('dx difference: ', rel_error(dx1, dx2))\n","print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n","print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n","print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"uIJWjzFZw73z"},"source":["# Spatial Batch Normalization\n","As proposed in the original paper, batch normalization can also be used for convolutional networks, but we need to tweak it a bit; the modification will be called \"spatial batch normalization.\"\n","\n","Normally batch-normalization accepts inputs of shape `(N, D)` and produces outputs of shape `(N, D)`, where we normalize across the minibatch dimension `N`. For data coming from convolutional layers, batch normalization needs to accept inputs of shape `(N, C, H, W)` and produce outputs of shape `(N, C, H, W)` where the `N` dimension gives the minibatch size and the `(H, W)` dimensions give the spatial size of the feature map.\n","\n","If the feature map was produced using convolutions, then we expect every feature channel's statistics e.g. mean, variance to be relatively consistent both between different images, and different locations within the same image -- after all, every feature channel is produced by the same convolutional filter! Therefore spatial batch normalization computes a mean and variance for each of the `C` feature channels by computing statistics over the minibatch dimension `N` as well the spatial dimensions `H` and `W`.\n","\n","\n","[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n","Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"]},{"cell_type":"code","metadata":{"id":"8Czv0Qu0BsDh"},"source":["class SpatialBatchNorm(object):\n","\n","  @staticmethod\n","  def forward(x, gamma, beta, bn_param):\n","    raise NotImplementedError\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    raise NotImplementedError"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"oqCmKCw7w730"},"source":["## Spatial batch normalization: forward\n","\n","Implement the forward pass for spatial batch normalization in the function `SpatialBatchNorm.forward`. Check your implementation by running the following:"]},{"cell_type":"code","metadata":{"id":"oBjsUeK_Bq7-"},"source":["def spatial_batchnorm_forward(x, gamma, beta, bn_param):\n","  \"\"\"\n","  Computes the forward pass for spatial batch normalization.\n","\n","  Inputs:\n","  - x: Input data of shape (N, C, H, W)\n","  - gamma: Scale parameter, of shape (C,)\n","  - beta: Shift parameter, of shape (C,)\n","  - bn_param: Dictionary with the following keys:\n","    - mode: 'train' or 'test'; required\n","    - eps: Constant for numeric stability\n","    - momentum: Constant for running mean / variance. momentum=0 means that\n","    old information is discarded completely at every time step, while\n","    momentum=1 means that new information is never incorporated. The\n","    default of momentum=0.9 should work well in most situations.\n","    - running_mean: Array of shape (D,) giving running mean of features\n","    - running_var Array of shape (D,) giving running variance of features\n","\n","  Returns a tuple of:\n","  - out: Output data, of shape (N, C, H, W)\n","  - cache: Values needed for the backward pass\n","  \"\"\"\n","  out, cache = None, None\n","\n","  ###########################################################################\n","  # TODO: Implement the forward pass for spatial batch normalization.       #\n","  #                                                                         #\n","  # HINT: You can implement spatial batch normalization by calling the      #\n","  # vanilla version of batch normalization you implemented above.           #\n","  # Your implementation should be very short; ours is less than five lines. #\n","  ###########################################################################\n","  # Replace \"pass\" statement with your code\n","  pass\n","  ###########################################################################\n","  #                             END OF YOUR CODE                            #\n","  ###########################################################################\n","\n","  return out, cache\n","\n","SpatialBatchNorm.forward = spatial_batchnorm_forward"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"5ZHLPa6-UkY1"},"source":["After implementing the forward pass for spatial batch normalization, you can run the following to sanity check your code."]},{"cell_type":"code","metadata":{"id":"3x-vfMnIw732"},"source":["fix_random_seed(0)\n","# Check the training-time forward pass by checking means and variances\n","# of features both before and after spatial batch normalization\n","\n","N, C, H, W = 2, 3, 4, 5\n","x = 4 * torch.randn(N, C, H, W, **to_double_cuda) + 10\n","\n","print('Before spatial batch normalization:')\n","print('  Shape: ', x.shape)\n","print('  Means: ', x.mean(dim=(0, 2, 3)))\n","print('  Stds: ', x.std(dim=(0, 2, 3)))\n","\n","# Means should be close to zero and stds close to one\n","gamma, beta = torch.ones(C, **to_double_cuda), torch.zeros(C, **to_double_cuda)\n","bn_param = {'mode': 'train'}\n","out, _ = SpatialBatchNorm.forward(x, gamma, beta, bn_param)\n","print('After spatial batch normalization:')\n","print('  Shape: ', out.shape)\n","print('  Means: ', out.mean(dim=(0, 2, 3)))\n","print('  Stds: ', out.std(dim=(0, 2, 3)))\n","\n","# Means should be close to beta and stds close to gamma\n","gamma, beta = torch.tensor([3, 4, 5], **to_double_cuda), torch.tensor([6, 7, 8], **to_double_cuda)\n","out, _ = SpatialBatchNorm.forward(x, gamma, beta, bn_param)\n","print('After spatial batch normalization (nontrivial gamma, beta):')\n","print('  Shape: ', out.shape)\n","print('  Means: ', out.mean(dim=(0, 2, 3)))\n","print('  Stds: ', out.std(dim=(0, 2, 3)))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"RxzqSGqZUr2J"},"source":["Similar to the vanilla batch normalization implementation, run the following to sanity-check the test-time forward pass of spatial batch normalization."]},{"cell_type":"code","metadata":{"id":"7z2Eu2Xlw736"},"source":["fix_random_seed(0)\n","# Check the test-time forward pass by running the training-time\n","# forward pass many times to warm up the running averages, and then\n","# checking the means and variances of activations after a test-time\n","# forward pass.\n","N, C, H, W = 10, 4, 11, 12\n","\n","bn_param = {'mode': 'train'}\n","gamma = torch.ones(C, **to_double_cuda)\n","beta = torch.zeros(C, **to_double_cuda)\n","for t in range(50):\n","  x = 2.3 * torch.randn(N, C, H, W, **to_double_cuda) + 13\n","  SpatialBatchNorm.forward(x, gamma, beta, bn_param)\n","bn_param['mode'] = 'test'\n","x = 2.3 * torch.randn(N, C, H, W, **to_double_cuda) + 13\n","a_norm, _ = SpatialBatchNorm.forward(x, gamma, beta, bn_param)\n","\n","# Means should be close to zero and stds close to one, but will be\n","# noisier than training-time forward passes.\n","print('After spatial batch normalization (test-time):')\n","print('  means: ', a_norm.mean(dim=(0, 2, 3)))\n","print('  stds: ', a_norm.std(dim=(0, 2, 3)))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"dVdE3j3iw739"},"source":["## Spatial batch normalization: backward\n","Implement the backward pass for spatial batch normalization in the function `SpatialBatchNorm.backward`."]},{"cell_type":"code","metadata":{"id":"v9TqgGJ0DlCV"},"source":["def spatial_batchnorm_backward(dout, cache):\n","  \"\"\"\n","  Computes the backward pass for spatial batch normalization.\n","  Inputs:\n","  - dout: Upstream derivatives, of shape (N, C, H, W)\n","  - cache: Values from the forward pass\n","  Returns a tuple of:\n","  - dx: Gradient with respect to inputs, of shape (N, C, H, W)\n","  - dgamma: Gradient with respect to scale parameter, of shape (C,)\n","  - dbeta: Gradient with respect to shift parameter, of shape (C,)\n","  \"\"\"\n","  dx, dgamma, dbeta = None, None, None\n","\n","  ###########################################################################\n","  # TODO: Implement the backward pass for spatial batch normalization.      #\n","  #                                                                         #\n","  # HINT: You can implement spatial batch normalization by calling the      #\n","  # vanilla version of batch normalization you implemented above.           #\n","  # Your implementation should be very short; ours is less than five lines. #\n","  ###########################################################################\n","  # Replace \"pass\" statement with your code\n","  pass\n","  ###########################################################################\n","  #                             END OF YOUR CODE                            #\n","  ###########################################################################\n","\n","  return dx, dgamma, dbeta\n","\n","SpatialBatchNorm.backward = spatial_batchnorm_backward"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"B5efGyfwU3rK"},"source":["After implementing the backward pass for spatial batch normalization, run the following to perform numeric gradient checking on your implementation. You should see errors less than `1e-6`."]},{"cell_type":"code","metadata":{"id":"5Z2j4mQlw73_"},"source":["fix_random_seed(0)\n","N, C, H, W = 2, 3, 4, 5\n","x = 5 * torch.randn(N, C, H, W, **to_double_cuda) + 12\n","gamma = torch.randn(C, **to_double_cuda)\n","beta = torch.randn(C, **to_double_cuda)\n","dout = torch.randn(N, C, H, W, **to_double_cuda)\n","\n","bn_param = {'mode': 'train'}\n","fx = lambda x: SpatialBatchNorm.forward(x, gamma, beta, bn_param)[0]\n","fg = lambda a: SpatialBatchNorm.forward(x, gamma, beta, bn_param)[0]\n","fb = lambda b: SpatialBatchNorm.forward(x, gamma, beta, bn_param)[0]\n","\n","dx_num = compute_numeric_gradient(fx, x, dout)\n","da_num = compute_numeric_gradient(fg, gamma, dout)\n","db_num = compute_numeric_gradient(fb, beta, dout)\n","\n","_, cache = SpatialBatchNorm.forward(x, gamma, beta, bn_param)\n","dx, dgamma, dbeta = SpatialBatchNorm.backward(dout, cache)\n","print('dx error: ', rel_error(dx_num, dx))\n","print('dgamma error: ', rel_error(da_num, dgamma))\n","print('dbeta error: ', rel_error(db_num, dbeta))"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"9qS4seVFEkAN"},"source":["# \"Sandwich\" layers with batch normalization\n","Again, below you will find sandwich layers that implement a few commonly used patterns for convolutional networks."]},{"cell_type":"code","metadata":{"id":"FUY0tkJTEkAU"},"source":["class Linear_BatchNorm_ReLU(object):\n","\n","  @staticmethod\n","  def forward(x, w, b, gamma, beta, bn_param):\n","    \"\"\"\n","    Convenience layer that performs an linear transform, batch normalization,\n","    and ReLU.\n","    Inputs:\n","    - x: Array of shape (N, D1); input to the linear layer\n","    - w, b: Arrays of shape (D2, D2) and (D2,) giving the weight and bias for\n","      the linear transform.\n","    - gamma, beta: Arrays of shape (D2,) and (D2,) giving scale and shift\n","      parameters for batch normalization.\n","    - bn_param: Dictionary of parameters for batch normalization.\n","    Returns:\n","    - out: Output from ReLU, of shape (N, D2)\n","    - cache: Object to give to the backward pass.\n","    \"\"\"\n","    a, fc_cache = Linear.forward(x, w, b)\n","    a_bn, bn_cache = BatchNorm.forward(a, gamma, beta, bn_param)\n","    out, relu_cache = ReLU.forward(a_bn)\n","    cache = (fc_cache, bn_cache, relu_cache)\n","    return out, cache\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    \"\"\"\n","    Backward pass for the linear-batchnorm-relu convenience layer.\n","    \"\"\"\n","    fc_cache, bn_cache, relu_cache = cache\n","    da_bn = ReLU.backward(dout, relu_cache)\n","    da, dgamma, dbeta = BatchNorm.backward(da_bn, bn_cache)\n","    dx, dw, db = Linear.backward(da, fc_cache)\n","    return dx, dw, db, dgamma, dbeta\n","\n","\n","class Conv_BatchNorm_ReLU(object):\n","\n","  @staticmethod\n","  def forward(x, w, b, gamma, beta, conv_param, bn_param):\n","    a, conv_cache = FastConv.forward(x, w, b, conv_param)\n","    an, bn_cache = SpatialBatchNorm.forward(a, gamma, beta, bn_param)\n","    out, relu_cache = ReLU.forward(an)\n","    cache = (conv_cache, bn_cache, relu_cache)\n","    return out, cache\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    conv_cache, bn_cache, relu_cache = cache\n","    dan = ReLU.backward(dout, relu_cache)\n","    da, dgamma, dbeta = SpatialBatchNorm.backward(dan, bn_cache)\n","    dx, dw, db = FastConv.backward(da, conv_cache)\n","    return dx, dw, db, dgamma, dbeta\n","\n","\n","class Conv_BatchNorm_ReLU_Pool(object):\n","\n","  @staticmethod\n","  def forward(x, w, b, gamma, beta, conv_param, bn_param, pool_param):\n","    a, conv_cache = FastConv.forward(x, w, b, conv_param)\n","    an, bn_cache = SpatialBatchNorm.forward(a, gamma, beta, bn_param)\n","    s, relu_cache = ReLU.forward(an)\n","    out, pool_cache = FastMaxPool.forward(s, pool_param)\n","    cache = (conv_cache, bn_cache, relu_cache, pool_cache)\n","    return out, cache\n","\n","  @staticmethod\n","  def backward(dout, cache):\n","    conv_cache, bn_cache, relu_cache, pool_cache = cache\n","    ds = FastMaxPool.backward(dout, pool_cache)\n","    dan = ReLU.backward(ds, relu_cache)\n","    da, dgamma, dbeta = SpatialBatchNorm.backward(dan, bn_cache)\n","    dx, dw, db = FastConv.backward(da, conv_cache)\n","    return dx, dw, db, dgamma, dbeta"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"1C8k4fRgwyp1"},"source":["# Convolutional nets with batch normalization\n","Now that you have a working implementation for batch normalization, go back to your [`DeepConvnet`](#scrollTo=Ah-_nwx2BSxl). Modify your implementation to add batch normalization.\n","\n","Concretely, when the `batchnorm` flag is set to `True` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last linear layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n","\n","In the reg=0 case, you should see errors less than `1e-6` for all weights and batchnorm parameters (beta and gamma); for biases you should see errors less than `1e-2`.\n","\n","In the reg=3.14 case, you should see errors less than `1e-6` for all parameters."]},{"cell_type":"code","metadata":{"id":"E5sLZ6J1wyp6"},"source":["num_inputs = 2\n","input_dims = (3, 8, 8)\n","num_classes = 10\n","fix_random_seed(0)\n","X = torch.randn(num_inputs, *input_dims, **to_double_cuda)\n","y = torch.randint(num_classes, size=(num_inputs,), **to_long_cuda)\n","\n","for reg in [0, 3.14]:\n","  print('Running check with reg = ', reg)\n","  model = DeepConvNet(input_dims=input_dims, num_classes=num_classes,\n","                      num_filters=[8, 8, 8],\n","                      max_pools=[0, 2],\n","                      reg=reg, batchnorm=True,\n","                      weight_scale='kaiming',\n","                      **to_double_cuda)\n","\n","  loss, grads = model.loss(X, y)\n","  # The relative errors should be up to the order of e-3\n","  for name in sorted(grads):\n","    f = lambda _: model.loss(X, y)[0]\n","    grad_num = compute_numeric_gradient(f, model.params[name])\n","    print('%s max relative error: %e' % (name, rel_error(grad_num, grads[name])))\n","  if reg == 0: print()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"T-D9TV8qwyp9"},"source":["# Batchnorm for deep convolutional networks\n","Run the following to train a deep convolutional network on a subset of 500 training examples both with and without batch normalization."]},{"cell_type":"code","metadata":{"id":"IrrKxsVGwyp_"},"source":["fix_random_seed(0)\n","\n","# Try training a deep convolutional net with batchnorm\n","num_train = 500\n","small_data = {\n","  'X_train': data_dict['X_train'][:num_train],\n","  'y_train': data_dict['y_train'][:num_train],\n","  'X_val': data_dict['X_val'],\n","  'y_val': data_dict['y_val'],\n","}\n","input_dims = data_dict['X_train'].shape[1:]\n","\n","bn_model = DeepConvNet(input_dims=input_dims, num_classes=10,\n","                       num_filters=[16, 32, 32, 64, 64],\n","                       max_pools=[0, 1, 2, 3, 4],\n","                       weight_scale='kaiming',\n","                       batchnorm=True,\n","                       reg=1e-5, **to_float_cuda)\n","model = DeepConvNet(input_dims=input_dims, num_classes=10,\n","                    num_filters=[16, 32, 32, 64, 64],\n","                    max_pools=[0, 1, 2, 3, 4],\n","                    weight_scale='kaiming',\n","                    batchnorm=False,\n","                    reg=1e-5, **to_float_cuda)\n","\n","print('Solver with batch norm:')\n","bn_solver = Solver(bn_model, small_data,\n","                   num_epochs=10, batch_size=100,\n","                   update_rule=adam,\n","                   optim_config={\n","                     'learning_rate': 1e-3,\n","                   },\n","                   print_every=20, device='cuda')\n","bn_solver.train()\n","\n","print('\\nSolver without batch norm:')\n","solver = Solver(model, small_data,\n","                num_epochs=10, batch_size=100,\n","                update_rule=adam,\n","                optim_config={\n","                  'learning_rate': 1e-3,\n","                },\n","                print_every=20, device='cuda')\n","solver.train()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"4XZ7jZE9wyqE"},"source":["Run the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster."]},{"cell_type":"code","metadata":{"id":"1oBBnMuGehfi"},"source":["def plot_training_history_bn(title, label, solvers, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n","  \"\"\"utility function for plotting training history\"\"\"\n","  plt.title(title)\n","  plt.xlabel(label)\n","  bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n","  bl_plots = [plot_fn(solver) for solver in solvers]\n","  num_bn = len(bn_plots)\n","  num_bl = len(bl_plots)\n","  for i in range(num_bn):\n","    label='w/ BN'\n","    if labels is not None:\n","      label += str(labels[i])\n","    plt.plot(bn_plots[i], bn_marker, label=label)\n","  for i in range(num_bl):\n","    label='w/o BN'\n","    if labels is not None:\n","      label += str(labels[i])\n","    plt.plot(bl_plots[i], bl_marker, label=label)\n","  plt.legend(loc='lower center', ncol=num_bn+num_bl)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"PVYMhWo9wyqG","tags":["pdf-ignore-input"]},"source":["plt.subplot(3, 1, 1)\n","plot_training_history_bn('Training loss','Iteration', [solver], [bn_solver], \\\n","                      lambda x: x.loss_history, bl_marker='-o', bn_marker='-o')\n","plt.subplot(3, 1, 2)\n","plot_training_history_bn('Training accuracy','Epoch', [solver], [bn_solver], \\\n","                      lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\n","plt.subplot(3, 1, 3)\n","plot_training_history_bn('Validation accuracy','Epoch', [solver], [bn_solver], \\\n","                      lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n","\n","plt.gcf().set_size_inches(15, 15)\n","plt.show()"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"YV6-pJEdSXMh"},"source":["# Batch normalization and learning rate\n","We will now run a small experiment to study the interaction of batch normalization and learning rate.\n","\n","The first cell will train convolutional networks with different learning rates. The second layer will plot training accuracy and validation set accuracy over time. You should find that using batch normalization helps the network to be less dependent to the learning rate."]},{"cell_type":"code","metadata":{"id":"yVSQ5SesSXMq","tags":["pdf-ignore-input"]},"source":["fix_random_seed(0)\n","\n","# Try training a very deep net with batchnorm\n","num_train = 10000\n","small_data = {\n","  'X_train': data_dict['X_train'][:num_train],\n","  'y_train': data_dict['y_train'][:num_train],\n","  'X_val': data_dict['X_val'],\n","  'y_val': data_dict['y_val'],\n","}\n","input_dims = data_dict['X_train'].shape[1:]\n","num_epochs = 5\n","lrs = [2e-1, 1e-1, 5e-2]\n","lrs = [5e-3, 1e-2, 2e-2]\n","\n","solvers = []\n","for lr in lrs:\n","  print('No normalization: learning rate = ', lr)\n","  model = DeepConvNet(input_dims=input_dims, num_classes=10,\n","                      num_filters=[8, 8, 8],\n","                      max_pools=[0, 1, 2],\n","                      weight_scale='kaiming',\n","                      batchnorm=False,\n","                      reg=1e-5, **to_float_cuda)\n","  solver = Solver(model, small_data,\n","                  num_epochs=num_epochs, batch_size=100,\n","                  update_rule=sgd_momentum,\n","                  optim_config={\n","                    'learning_rate': lr,\n","                  },\n","                  verbose=False, device='cuda')\n","  solver.train()\n","  solvers.append(solver)\n","\n","bn_solvers = []\n","for lr in lrs:\n","  print('Normalization: learning rate = ', lr)\n","  bn_model = DeepConvNet(input_dims=input_dims, num_classes=10,\n","                         num_filters=[8, 8, 16, 16, 32, 32],\n","                         max_pools=[1, 3, 5],\n","                         weight_scale='kaiming',\n","                         batchnorm=True,\n","                         reg=1e-5, **to_float_cuda)\n","  bn_solver = Solver(bn_model, small_data,\n","                     num_epochs=num_epochs, batch_size=128,\n","                     update_rule=sgd_momentum,\n","                     optim_config={\n","                       'learning_rate': lr,\n","                     },\n","                     verbose=False, device='cuda')\n","  bn_solver.train()\n","  bn_solvers.append(bn_solver)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"kBE8AT5SSXMv"},"source":["plt.subplot(2, 1, 1)\n","plot_training_history_bn('Training accuracy (Batch Normalization)','Epoch', solvers, bn_solvers, \\\n","                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=[' lr={:.0e}'.format(lr) for lr in lrs])\n","plt.subplot(2, 1, 2)\n","plot_training_history_bn('Validation accuracy (Batch Normalization)','Epoch', solvers, bn_solvers, \\\n","                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=[' lr={:.0e}'.format(lr) for lr in lrs])\n","\n","plt.gcf().set_size_inches(15, 10)\n","plt.show()"],"execution_count":null,"outputs":[]}]}